StableHLO के साथ काम करने की सुविधा

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

वर्शन

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

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

गारंटी

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

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

* 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 API के लिए StablehloModule.cpp देखें.

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

जांच

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

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

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

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

आउट ऑफ़ स्कोप

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

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

गड़बड़ी के साथ काम करने की सुविधा: अगर libStablehlo को लागू करने का तरीका StableHLO की विशेषता से मेल नहीं खाता है, तो हम बेमेल बदलाव कर सकते हैं. उदाहरण के लिए, अगर VHLO भाषा में कोई परिभाषा गलत है या StableHLO भाषा में मौजूद पुष्टि करने वाला टूल, खास जानकारी से मेल नहीं खाता.

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

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