लाइब्रेरी डिज़ाइन
Tokamax को इस तरह डिज़ाइन किया गया है कि डेवलपर को कर्नल बनाने, उसे ऑप्टिमाइज़ करने, उसका रखरखाव करने, और प्रोडक्शन में इस्तेमाल करने के दौरान, स्टैंडर्ड और आसान प्रोसेस मिले. यह काम, फ़ाउंडेशनल क्लास और शेयर किए गए इन्फ़्रास्ट्रक्चर की मदद से किया जाता है. लाइब्रेरी में मौजूद सभी ऑपरेटर, इन्हें इनहेरिट करते हैं और एक व्यवस्थित फ़्रेमवर्क में लागू करते हैं.
ऑपरेटर लेयर
Tokamax Base Class
tokamax.Op
Tokamax की बुनियादी क्लास है. यह लाइब्रेरी में मौजूद हर ऑपरेटर के लिए बेस के तौर पर काम करती है. जब किसी डिराइव्ड ऑपरेटर को शुरू किया जाता है, तो यह लेयर अपने-आप
इन सुविधाओं को मैनेज करती है:
- आर्ग्युमेंट बाइंडिंग: किसी भी कंप्यूटेशन के चलने से पहले, बेस क्लास कॉलर के आर्ग्युमेंट को सामान्य बनाती है और उनकी पुष्टि करती है. इसके बाद, उन्हें एक कैननिकल रिप्रज़ेंटेशन में बदलती है, ताकि कैश मेमोरी, ह्यूरिस्टिक, और कर्नेल एक्ज़ीक्यूशन, सभी वर्कलोड को एक जैसा समझ सकें. इसके लिए,
BoundArgumentsऑब्जेक्ट का इस्तेमाल किया जाता है. इससे कोई फ़र्क़ नहीं पड़ता कि इनपुट कैसे पास किए गए थे. ज़्यादा जानकारी के लिए,op.bind()देखें. - डिवाइस की पुष्टि करना: हार्डवेयर के मेल न खाने की समस्या का जल्द पता लगाने के लिए, ऑपरेटर कोड को चलाने से पहले, टारगेट ऐक्सेलरेटर के साथ डिवाइस के काम करने की पुष्टि करता है. हालांकि, सीपीयू होस्ट से क्रॉस-कंपाइल करते समय, इस जांच को बायपास किया जा सकता है. ज़्यादा जानकारी के लिए,
op.supported_on(),bypass_device_check=True, औरconfig.cross_compile(True)देखें. - बैचिंग कैप्चर: सबसे सही कर्नेल कॉन्फ़िगरेशन
(
Config) अक्सर एक स्लाइस के बजाय, पूरे बैच की समस्या के साइज़ पर निर्भर करता है. इसलिए, जब किसी ऑपरेटर को वेक्टराइज़ किया जाता है, तो बेस क्लास आस-पास के बैच डाइमेंशन को कैप्चर करती है (jax.vmap). इससे ह्यूरिस्टिक और ऑटोट्यूनिंग कैश मेमोरी, असल वर्कलोड के साइज़ के लिए ऑप्टिमाइज़ हो सकती है (देखेंop._capture_batched_args()). - कॉन्फ़िगरेशन रिज़ॉल्यूशन: मैन्युअल ट्यूनिंग की ज़रूरत के बिना, बेहतर परफ़ॉर्मेंस देने के लिए, बेस क्लास कर्नेल हाइपर पैरामीटर को अपने-आप रिज़ॉल्व करती है. ऐसा तब होता है, जब कॉलर उन्हें उपलब्ध नहीं कराता. इसके लिए, डिस्क पर आधारित ऑटोट्यूनिंग कैश मेमोरी में पहले से मौजूद ऑटोट्यून की गई सेटिंग का फिर से इस्तेमाल किया जाता है. अगर ये सेटिंग उपलब्ध नहीं हैं, तो पहले से मौजूद ह्यूरिस्टिक का इस्तेमाल किया जाता है (
BoundArguments.default_configदेखें). - StableHLO मेटाडेटा सीरियलाइज़ेशन: कंपाइल किए गए प्रोग्राम को ऑफ़लाइन प्रोफ़ाइलिंग और ऑटोमेटेड ट्यूनिंग के लिए, बेस क्लास ऑपरेटर मेटाडेटा को लोअर किए गए ग्राफ़ में एम्बेड करती है. इससे डाउनस्ट्रीम टूल, कंपाइल किए गए मॉड्यूल या परफ़ॉर्मेंस प्रोफ़ाइल से सीधे तौर पर यह पता लगा सकते हैं कि कौनसे ऑपरेटर चलाए गए और किन इनपुट (शेप, टाइप वगैरह) के साथ चलाए गए (
_tokamax_metadata()देखें). - फ़ॉरवर्ड एक्ज़ीक्यूशन और कस्टम वीजेपी: खास हार्डवेयर कर्नेल को अक्सर स्टैंडर्ड ऑटोमैटिक डिफ़रेंशिएशन से अलग नहीं किया जा सकता. इसलिए, बेस क्लास फ़ॉरवर्ड और बैकवर्ड एक्ज़ीक्यूशन को एक पेयर के तौर पर कोऑर्डिनेट करती है. इससे फ़ॉरवर्ड पास, ग्रेडिएंट कंप्यूटेशन के दौरान इंटरमीडिएट वैल्यू को सीधे कस्टम बैकवर्ड कर्नेल को पास कर सकता है. इसके बारे में ज़्यादा जानने के लिए,
op._fwd()देखें. साथ ही,jax.custom_vjpको कॉल करता है.
Op-Specific Base Class
हर ऑपरेटर फ़ैमिली अपनी बेस क्लास तय करती है, जो बुनियादी ऑपरेटर क्लास से इनहेरिट होती है. साथ ही, यह सभी बैकएंड के साथ शेयर किए गए कॉन्ट्रैक्ट को तय करती है. उदाहरण के लिए, RaggedDot देखें:
- रेफ़रंस के तौर पर लागू करना: हर ऑपरेटर बेस क्लास, पूरी गणितीय जानकारी को रेफ़रंस के तौर पर लागू करने के लिए, पोर्टेबल और प्योर-JAX उपलब्ध कराती है. इसमें लागू होने पर ग्रेडिएंट भी शामिल होते हैं. यह संख्या के सही होने की जांच के लिए, ज़मीनी हकीकत के तौर पर काम करता है. साथ ही, यह गारंटी देता है कि किसी भी हार्डवेयर पर फ़ॉलबैक काम करेगा (
RaggedDot._fwd()देखें). - कैननिकल बाइंडिंग: उपयोगकर्ता एक ही गणितीय ऑपरेशन को कई तरीकों से दिखा सकते हैं. जैसे, मास्क के अलग-अलग फ़ॉर्म, सटीक सेटिंग या डाइमेंशन की खास जानकारी पास करना. इसलिए, ऑपरेटर बेस क्लास इनपुट को सामान्य बनाती है और आकार और टाइप की अनुकूलता की जांच पहले ही कर लेती है. इससे अलग-अलग हार्डवेयर बैकएंड को सिर्फ़ एक, अनुमानित इनपुट फ़ॉर्मैट को हैंडल करना पड़ता है (
RaggedDot.bind()देखें).
ऑपरेशन लागू करने वाली क्लास
ये क्लास, हार्डवेयर के हिसाब से कर्नेल को लागू करने की सुविधा देती हैं. साथ ही, उपयोगकर्ता इन्हें सीधे तौर पर इंस्टैंशिएट और शुरू कर सकते हैं. हर इंप्लिमेंटेशन, ऑपरेटर के हिसाब से अपनी बेस क्लास से इनहेरिट करता है और बैकएंड के हिसाब से काम करता है. उदाहरण के लिए, PallasMosaicTpuRaggedDot देखें:
- मुख्य फ़ंक्शन: यहां हार्डवेयर कर्नेल के असल एक्ज़ीक्यूशन के बारे में बताया जाता है. आम तौर पर, इसके लिए Pallas जैसी कर्नेल भाषा का इस्तेमाल किया जाता है. जब किसी ऑपरेशन के लिए खास बैकवर्ड पास की ज़रूरत होती है, तो ग्रेडिएंट कर्नेल को आम तौर पर उसके अपने फ़र्स्ट-क्लास ऑपरेटर के तौर पर मॉडल किया जाता है, ताकि उसे अलग से कॉन्फ़िगर, ट्यून, और टेस्ट किया जा सके. हालांकि, सबसे निचले लेवल के कर्नेल कोड को अक्सर मॉड्यूलरिटी के लिए एक अलग हेल्पर फ़ाइल में शामिल किया जाता है, लेकिन यह क्लास उस कर्नेल को शुरू करने के लिए मुख्य इंटरफ़ेस के तौर पर काम करती है (
PallasMosaicTpuRaggedDot._fwd()देखें). - कॉन्फ़िगरेशन: हार्डवेयर कर्नेल अक्सर परफ़ॉर्मेंस नॉब को एक्सपोज़ करते हैं. जैसे, टाइल के साइज़, पाइपलाइन स्टेज या मेमोरी बफ़रिंग की रणनीतियां. हर बैकएंड एक खास कॉन्फ़िगरेशन स्ट्रक्चर तय करता है. इससे उपयोगकर्ता या ऑटोमेटेड टूल यह कंट्रोल कर सकते हैं कि कर्नेल को कैसे बांटा जाए, कंपाइल किया जाए, और लागू किया जाए (
Configदेखें). - ह्यूरिस्टिक्स: हर वर्कलोड को पहले से ऑटो-ट्यून नहीं किया जाता. इसलिए, हर बैकएंड में पहले से मौजूद ह्यूरिस्टिक्स होते हैं. ये समस्या के डाइमेंशन, डेटा टाइप, और ऐक्सेलरेटर की खास बातों के आधार पर, डिफ़ॉल्ट ट्यूनिंग पैरामीटर चुनते हैं (
_get_heuristics_config()देखें). - ऑटोट्यूनिंग सर्च स्पेस: ऐसे वर्कलोड के लिए जिनमें बेहतरीन परफ़ॉर्मेंस ज़रूरी है, हर बैकएंड किसी समस्या के लिए मान्य पैरामीटर कॉम्बिनेशन का ऑटोट्यूनिंग सर्च स्पेस तय करता है. इससे ऑटोट्यूनर, कैंडिडेट को बेंचमार्क कर सकता है और सबसे तेज़ कॉन्फ़िगरेशन का पता लगा सकता है (
_get_autotuning_configs()देखें). - लागू करने के लिए खास पुष्टि: हार्डवेयर कर्नेल में अक्सर सामान्य गणितीय ऑपरेशन की तुलना में ज़्यादा सख्त शर्तें होती हैं. जैसे, डाइमेंशन अलाइनमेंट के नियम या सीमित डेटा टाइप के लिए सहायता. हर इंप्लिमेंटेशन इन सीमाओं की पुष्टि करता है और वर्कलोड को हैंडल न कर पाने पर सिग्नल भेजता है. इससे, हाई-लेवल डिस्पैचर को दूसरे बैकएंड पर आसानी से स्विच करने की सुविधा मिलती है. ज़्यादा जानकारी के लिए,
PallasMosaicTpuRaggedDot._fwd()देखें.
हाई-लेवल एपीआई
ज़्यादातर ऑपरेटर के पास कई बैकएंड होते हैं. जैसे, एक या उससे ज़्यादा हार्डवेयर-विशिष्ट कर्नेल के साथ पोर्टेबल रेफ़रंस लागू करना. साथ ही, वे एक जाने-पहचाने, हाई-लेवल एंट्री पॉइंट को एक्सपोज़ करते हैं. उदाहरण के लिए, स्टैंडर्ड jax.lax फ़ंक्शन. इस लेयर को उपयोगकर्ताओं को एक आसान, ड्रॉप-इन इंटरफ़ेस देने के लिए डिज़ाइन किया गया है. यह इंटरफ़ेस, उनके हार्डवेयर और इनपुट शेप के लिए सबसे सही बैकएंड को अपने-आप चुनता है. हालांकि, उपयोगकर्ता चाहें, तो किसी खास तरीके से लागू करने का अनुरोध भी कर सकते हैं. इसके लिए, tokamax.ragged_dot() देखें.
ArgSpecs
बैकएंड पर कर्नेल को लगातार टेस्ट और ऑप्टिमाइज़ करने के लिए, ज़रूरी वर्कलोड शेप का एक शेयर किया गया कैटलॉग बनाए रखना ज़रूरी है. Tokamax, प्रोडक्शन और मानदंड के इन शेप को वर्कलोड की खास जानकारी के तौर पर कैप्चर करता है. इन्हें किसी ऑपरेटर के सभी इंप्लिमेंटेशन के साथ शेयर किया जाता है. इससे लगातार इंटिग्रेशन टेस्ट, रिग्रेशन बेंचमार्क, और ऑटोट्यूनिंग पाइपलाइन को एकमात्र भरोसेमंद सोर्स मिलता है. इसे अलग-अलग वर्कफ़्लो के लिए टैग के हिसाब से फ़िल्टर किया जा सकता है. ragged_dot के लिए ArgSpecs देखें.
डेटा स्टोर करने की जगह का स्ट्रक्चर
इंटरनल इंप्लिमेंटेशन कोड, निजी सोर्स ट्री में मौजूद होता है (देखें
tokamax/_src),
जबकि ऑपरेटर, ऑटोट्यूनिंग, मानदंड, और कॉन्फ़िगरेशन के लिए सार्वजनिक सिंबल,
टॉप-लेवल मॉड्यूल के ज़रिए फिर से एक्सपोर्ट किए जाते हैं (देखें
tokamax/__init__.py).
हर ऑपरेटर डायरेक्ट्री (tokamax/_src/ops देखें) में, फ़ाइलों के नाम रखने का एक जैसा तरीका अपनाया जाता है. इसे यहां रैग्ड डॉट का इस्तेमाल करके दिखाया गया है:
- हाई-लेवल एपीआई: यह सार्वजनिक फ़ंक्शनल एंट्री पॉइंट और बैकएंड डिस्पैच लॉजिक को तय करता है (
api.pyदेखें). - ऑपरेशन के हिसाब से बेस क्लास: यह पोर्टेबल रेफ़रंस लागू करने के बारे में बताती है (
base.pyदेखें). - बैकएंड इंप्लिमेंटेशन: यह हार्डवेयर के हिसाब से ऑपरेटर क्लास, कॉन्फ़िगरेशन, ह्यूरिस्टिक, और ऑटोट्यूनिंग स्पेस तय करता है (
pallas_mosaic_tpu.pyदेखें). - लो-लेवल कर्नेल: अलग से मौजूद कर्नेल इंप्लिमेंटेशन और शेयर किए गए लो-लेवल हेल्पर को कंपैनियन मॉड्यूल में अलग करता है (
pallas_mosaic_tpu_kernel.pyदेखें). - वर्कलोड की खास जानकारी: टेस्टिंग, मानदंड, और ऑटोट्यूनिंग के लिए कैननिकल इनपुट शेप को कैटलॉग करता है (
arg_specs.pyदेखें). - टेस्ट सुइट: हर बैकएंड टेस्ट सुइट के साथ-साथ, शेयर किए गए पैरामीटर वाले सही होने की जांच को तय करता है (
test_base.pyदेखें).
experimental डायरेक्ट्री में मौजूद Ops का स्ट्रक्चर एक जैसा होता है. हालांकि, हो सकता है कि उन्हें सार्वजनिक एपीआई में न दिखाया जाए. इन ऑपरेशंस का मकसद, तेज़ी से बदलाव करना और नई चीज़ें एक्सप्लोर करना है. इनमें अक्सर और काफ़ी बदलाव हो सकते हैं. आम तौर पर, इनके रखरखाव और सहायता की उम्मीदें कम होती हैं.
उपयोगकर्ताओं को कौनसा लेयर कॉल करना चाहिए
एंट्री पॉइंट चुनना, मुख्य रूप से सुविधा और कंट्रोल के बीच का समझौता है. ज़्यादातर उपयोगकर्ताओं को हाई-लेवल फ़ंक्शनल एपीआई के ज़रिए ऑपरेटर को कॉल करके शुरुआत करनी चाहिए. यह एपीआई, जाने-पहचाने स्टाइल वाला इंटरफ़ेस उपलब्ध कराता है और बैकएंड को लागू करने के लिए सही विकल्प अपने-आप चुनता है. जब डिटरमिनिस्टिक बैकएंड चुनने की ज़रूरत होती है, तब उपयोगकर्ता कॉल सिग्नेचर को एक जैसा रखते हुए, हाई-लेवल फ़ंक्शन को साफ़ तौर पर लागू करने का विकल्प पास कर सकते हैं. ज़्यादा से ज़्यादा कंट्रोल के लिए, उपयोगकर्ता सीधे तौर पर किसी खास ऑपरेटर को लागू करने वाली क्लास को इंस्टैंशिएट कर सकते हैं. इससे, कर्नेल हाइपर पैरामीटर को पसंद के मुताबिक बनाया जा सकता है. जैसे, टाइल के साइज़. साथ ही, बैकएंड के हिसाब से आर्ग्युमेंट पास किए जा सकते हैं.
हमारा सुझाव है कि ऑपरेटर को लागू करने वाली क्लास का इस्तेमाल किए बिना, सीधे तौर पर लो-लेवल कर्नेल फ़ंक्शन को कॉल न करें. ऐसा करने से, ज़रूरी इन्फ़्रास्ट्रक्चर को बायपास कर दिया जाता है. इसमें ऑटोट्यूनिंग, इनपुट की पुष्टि करना, कैनोनिकलाइज़ेशन, और मेटाडेटा को क्रम से लगाना शामिल है. हालांकि, इससे ओवरहेड में कोई खास बचत नहीं होती, क्योंकि ऑपरेटर रैपर जान-बूझकर हल्के बनाए जाते हैं. उदाहरण के लिए, अपने-आप ट्यून होने वाले सही हाइपर पैरामीटर के बिना, उपयोगकर्ताओं को परफ़ॉर्मेंस में काफ़ी गिरावट दिख सकती है.
उन्नत विषय
Operator Fusion
फ़्यूज़ किए जा सकने वाले Pallas TPU ऑपरेटर, @tokamax.ops.op_fusion.fuse के ज़रिए आस-पास के JAX प्रोलॉग और एपिलॉग को सीधे कर्नेल में फ़्यूज़ करने की सुविधा देते हैं. इस्तेमाल के उदाहरणों के साथ-साथ, फ़्यूज़न के साथ काम करने वाले कर्नेल और Op सबक्लास बनाने के निर्देशों के लिए, ऑपरेटर फ़्यूज़न गाइड देखें.
एपिसोड क्रम से लगाने की सेटिंग
कर्नेल को StableHLO में सीरियलाइज़ किया जा सकता है. कर्नेल कॉल, JAX कस्टम कॉल होते हैं. ये डिफ़ॉल्ट रूप से jax.export में प्रतिबंधित होते हैं. इनके लिए tokamax.DISABLE_JAX_EXPORT_CHECKS का इस्तेमाल करना ज़रूरी है, ताकि सभी Tokamax कर्नेल एक्सपोर्ट किए जा सकें:
from jax import export
f_grad_exported = export.export(f_grad, disabled_checks=tokamax.DISABLE_JAX_EXPORT_CHECKS)(
jax.ShapeDtypeStruct(x.shape, x.dtype),
jax.ShapeDtypeStruct(scale.shape, scale.dtype),
)
ध्यान दें कि Tokamax कर्नेल के साथ सीरियलाइज़ किए गए फ़ंक्शन, स्टैंडर्ड StableHLO की तरह किसी भी डिवाइस पर काम नहीं करते. Tokamax, सीरियलाइज़ेशन की दो गारंटी देता है:
- किसी खास डिवाइस पर सीरियलाइज़ किए गए डीसीरियलाइज़ फ़ंक्शन को उसी डिवाइस पर चलाया जा सकेगा जिसके लिए उसे सीरियलाइज़ किया गया था.
- Tokamax, JAX की तरह ही पुराने सिस्टम के साथ काम करने की सुविधा की गारंटी देता है: यह छह महीने पुराने सिस्टम के साथ काम करता है.
क्रॉस-कंपाइलेशन और सीपीयू एक्सपोर्ट
Tokamax कर्नेल को सीपीयू होस्ट पर एक्सपोर्ट या क्रॉस-कंपाइल किया जा सकता है:
- साफ़ तौर पर चुने गए सिस्टम (जैसे,
implementation="mosaic_tpu_v2") के लिए, होस्ट डिवाइस की पुष्टि करने की प्रोसेस अपने-आप बायपास हो जाती है. - इसके अलावा,
tokamax.config.cross_compile(True)का इस्तेमाल करके, दुनिया भर में क्रॉस-कंपाइलेशन की सुविधा चालू करें:
with tokamax.config.cross_compile(True):
f_exported = export.export(
f, disabled_checks=tokamax.DISABLE_JAX_EXPORT_CHECKS
)(
jax.ShapeDtypeStruct(x.shape, x.dtype),
...,
)