StableHLO कंपैटिबिलिटी

StableHLO, HLO/MHLO से प्रेरित एक पुराने सिस्टम के साथ काम करने वाला ML कंप्यूट ऑपसेट है. इस दस्तावेज़ में यह बताया गया है कि StableHLO के साथ काम करने की किस तरह की और किस सीमा तक गारंटी मिलती है, यह जानकारी RFC के साथ काम करने की प्रोसेस में बताई गई प्रोसेस के आधार पर तय होती है.

वर्शन

StableHLO का मौजूदा वर्शन, Version.h में देखा जा सकता है.

जब भी StableHLO ऑपसेट या StableHLO सीरियलाइज़ेशन फ़ॉर्मैट में बदलाव किया जाता है, तो माइनर वर्शन बंद हो जाता है. साथ ही, जब भी हम StableHLO डाउनस्ट्रीम को इंटिग्रेट करते हैं, तो पैच वर्शन आ जाता है, जैसे कि openxla/xla रिपॉज़िटरी में.

गारंटी

StableHLO v1.0 कम्पैटबिलटी आरएफ़सी के मुताबिक, साथ काम करने वाली विंडो में ये चीज़ें शामिल होती हैं:

पिछले वर्शन के साथ काम करने की सुविधा: libStablehlo के पुराने वर्शन से सीरियल नंबर वाले पोर्टेबल आर्टफ़ैक्ट का मतलब* तब ही होता है, जब इन वर्शन को Openxla/stablehlo के लिए बनाया गया हो और ये पांच साल से छोटे हों.

दो साल पहले के साथ काम करने की सुविधा: libStablehlo के नए वर्शन के क्रम में लगाई गई पोर्टेबल आर्टफ़ैक्ट का सिमेंटिक्स* तब मिलता है, जब उसे Openxla/stablehlo के पुराने वर्शन से बनाया गया हो. ऐसा तब होता है, जब प्रोग्राम में पुराने वर्शन से शुरू की गई नई सुविधाओं का इस्तेमाल किया जा रहा हो.

* StableHLO प्रोग्राम को कंपैटिबिलिटी एपीआई की मदद से, पोर्टेबल आर्टफ़ैक्ट से बदला जाता है. साथ ही, इन प्रोग्राम के सिमैंटिक को StableHLO स्पेसिफ़िकेशन से तय किया जाता है. साथ काम करने की इस परिभाषा के तहत जो चीज़ें शामिल नहीं हैं उनके उदाहरण देखने के लिए, "आउट ऑफ़ स्कोप" सेक्शन देखें.

API

पोर्टेबल आर्टफ़ैक्ट, stablehlo-translate टूल का इस्तेमाल करके या सीधे C++ या Python API में बनाए जा सकते हैं. क्रम से लगाने के लिए, #.#.# फ़ॉर्मैट में लिखे गए आर्टफ़ैक्ट को लिखने के लिए, StableHLO का टारगेट वर्शन होना ज़रूरी है. (मौजूदा वर्शन के लिए, Version.h देखें). पैच वर्शन के काम करने की क्षमता पर कोई असर नहीं पड़ता. इसलिए, क्रम से लगाने के दौरान, नॉन-ज़ीरो पैच वर्शन वाला कोई भी टारगेट डिफ़ॉल्ट रूप से शून्य पर सेट हो जाता है. डीसीरियलाइज़ेशन किसी आर्टफ़ैक्ट को पढ़ने के लिए, StableHLO के मौजूदा वर्शन का इस्तेमाल करता है.

stablehlo-translate

यह पोर्टेबल आर्टफ़ैक्ट बनाने और पढ़ने का सबसे आसान तरीका है.

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

प्रोग्राम के हिसाब से अपने-आप काम करने वाले वर्कफ़्लो के लिए, StableHLO नीचे दिए गए काम करने वाले एपीआई उपलब्ध कराता है:

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

सभी एपीआई के लिए, stablehlo/api/PortableApi.h और stablehlo/dialect/Serialization.h देखें.

उदाहरण के लिए, इन एपीआई के इस्तेमाल के बारे में जानने के लिए, StablehloTranslateMain.cpp देखें.

Python

StableHLO, C++ के साथ काम करने वाले एपीआई के लिए Python बाइंडिंग भी उपलब्ध कराता है:

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: ...

पूरे Python एपीआई के बारे में जानने के लिए, StablehloModule.cpp पर जाएं.

Python सीरियलाइज़ेशन एपीआई इस्तेमाल करने के राउंडट्रिप के उदाहरणों के लिए, stablehlo.py > test_serialization_apis पर जाएं.

जांच

हमारे पास stablehlo/tests/vhlo में कम्पैटबिलटी सुइट है. इसमें StableHLO ऑपरेशन वाले सभी वर्शन के लिए एक पूरा कलेक्शन है. हर पुल के अनुरोध के लिए, हम पुराने और आगे के साथ काम करने की सुविधा की जांच कर रहे हैं - इसका मतलब है कि सुइट को डीसीरियलाइज़्ड टारगेटिंग head (पीछे की ओर से काम करने की सुविधा) किया जा सकता है, कंपेंडियम को उसके साथ काम करने वाले सभी StableHLO वर्शन (फ़ॉरवर्ड कंपैटिबिलिटी) को टारगेट करने के लिए, क्रम से लगाया जा सकता है. साथ ही, नतीजे भी मूल StableHLO प्रोग्राम से मिलते-जुलते हैं.

आने वाले समय में किए जाने वाले काम

एमएलआईआर अपस्ट्रीम में एक कम्पैटबिलटी सुइट बनाएं: StableHLO गारंटी को बनाने और उसे बनाए रखने से मिली सीख का इस्तेमाल करके, हम MLIR अपस्ट्रीम के लिए एक कंपैटिबिलिटी सुइट में योगदान देने की योजना बना रहे हैं, ताकि MLIR बाइटकोड इन्फ़्रास्ट्रक्चर में गलती से होने वाली गड़बड़ियों का जल्दी पता लगाया जा सके (#1632).

रेफ़रंस को लागू करने का इस्तेमाल करें: फ़िलहाल, कम्पैटबिलटी को टेस्ट करने में libStablehlo के पुराने वर्शन के मुताबिक, क्रम से लगाए गए कम्पैटबिलटी सुइट को डिसीरियलाइज़ करने (डीसीरियलाइज़ेशन) का काम होता है. साथ ही, यह पक्का किया जाता है कि डीसीरियलाइज़ेशन से, वाक्य की तरह एक जैसे प्रोग्राम बनाए जाएं. हम इन टेस्ट में, रेफ़रंस इंप्लिमेंटेशन का भी इस्तेमाल करने की योजना बना रहे हैं. इससे, वाक्य की पहचान करने की बहुत ही मुश्किल ज़रूरत को कम करने और पहचान फ़ाइल को लागू करने की पूरी तरह से जांच करने में मदद मिलेगी (#1245).

आउट ऑफ़ स्कोप

पोर्ट न किए जा सकने वाले ऐसे आर्टफ़ैक्ट: साथ काम करने की गारंटी, सिर्फ़ उन आर्टफ़ैक्ट के लिए दी जाती है जिन्हें पोर्ट किया जा सकता है और जिन्हें बहुत ही खास तरीके से बनाया गया है. दूसरी तरह की आर्टफ़ैक्ट, जैसे कि StableHLO बोली का सुंदर प्रिंट वर्शन या StableHLO बोली का बाइट कोड होना, काम करने की गारंटी की कोई गारंटी नहीं होती.

बिना जानकारी वाली सुविधाएं: हम उन सुविधाओं में ऐसे बदलाव कर सकते हैं जो पहले भी StableHLO प्रोग्राम में काम करती हैं, लेकिन अभी तक StableHLO की सुविधाओं का हिस्सा नहीं हैं. उदाहरण के लिए, हम बिना रजिस्ट्रेशन वाली विशेषताओं के साथ काम करने की गारंटी नहीं देते.

गड़बड़ी के साथ काम करने की सुविधा: अगर libStablehlo में लागू किए गए तरीके से StableHLO की जानकारी मेल नहीं खाती है, तो हम ऐसे बदलाव कर सकते हैं जो

संख्या के हिसाब से सटीक: StableHLO में ऐसे कई विकल्प हैं जिनके लिए उपभोक्ताओं के लिए और यहां तक कि एक ही उपभोक्ता के लिए सभी वर्शन में उसे लागू करने से जुड़ी सटीक जानकारी दी गई है. ऐसे में, StableHLO का मकसद संख्या के हिसाब से सटीक होने की गारंटी देना नहीं है. हालांकि, आने वाले समय में इसमें बदलाव हो सकता है (#1156).

libStablehlo में C, C++, और Python API के लिए सोर्स कम्पैटबिलटी वाला लक्ष्य होना चाहिए. फ़िलहाल, हम सोर्स के साथ काम करने की गारंटी नहीं देते, लेकिन अगर आपके लिए यह ज़रूरी इस्तेमाल का उदाहरण है, तो कृपया हमें बताएं. हम इसे पूरा करने के बारे में चर्चा कर सकते हैं (#1247).