-sdy-close-shardings

टेंसर शार्डिंग बंद करता है और डुप्लीकेट किए गए ऐक्सिस को हटाता है.

-sdy-constant-or-scalar-merger

एक जैसे कॉन्स्टेंट और स्केलर एक्सपैंशन को मैचिंग शार्डिंग के साथ मर्ज करता है.

एक जैसी शार्डिंग वाले कॉन्स्टेंट पर, हल्के-फुल्के CSE की प्रोसेस पूरी करता है.

इंपोर्ट पाइपलाइन, कॉन्स्टेंट और स्केलर एक्सपैंशन को इस तरह से बांटती और डुप्लीकेट करती है कि कॉन्स्टेंट सब-कंप्यूटेशन के अलग-अलग इस्तेमाल के बीच शार्डिंग को आगे न बढ़ाया जा सके. अगर कॉन्स्टेंट में आगे बढ़ाने के बाद भी एक जैसी शार्डिंग होती है, तो यह पास उन्हें मर्ज कर देता है, ताकि कंपाइलेशन में लगने वाला समय बचाया जा सके. ज़्यादा जानकारी के लिए, -sdy-constant-or-scalar-splitter देखें.

-sdy-convert-global-to-local

एसडीवाई प्रोग्राम को ग्लोबल शेप से लोकल शेप में बदलता है.

एसडीवाई प्रोग्राम को ग्लोबल शेप से लोकल शेप में बदलने के लिए, शार्डिंग एट्रिब्यूट के आधार पर लॉजिकल डाइमेंशन को बांटा जाता है.

यह पास, RankedTensorType को ग्लोबल लॉजिकल शेप से डिवाइस-लोकल फ़िज़िकल शेप में मैप करने के लिए, टाइप कनवर्टर का इस्तेमाल करता है.

-sdy-drop-sharding-rules

रजिस्टर्ड सभी ऑप्स से OpShardingRuleAttr को हटाता है.

-sdy-insert-explicit-reshards

सभी कार्रवाइयों में काम करने वाली शार्डिंग जोड़ने के लिए, साफ़ तौर पर रीशार्ड जोड़ता है.

काम करने वाली शार्डिंग का मतलब है कि कार्रवाई, शार्ड किए गए ऑपरेंड को स्वीकार कर सकती है और रीशार्ड कम्यूनिकेशन की ज़रूरत के बिना, शार्ड किया गया नतीजा दे सकती है. ध्यान दें कि कार्रवाई के लिए, अब भी कम्यूनिकेशन की ज़रूरत पड़ सकती है. जैसे, ऑल-रिड्यूस या हेलो-स्वैप.

आगे बढ़ाने के बाद, कुछ कार्रवाइयों में अब भी काम न करने वाली शार्डिंग हो सकती है.

ध्यान दें कि जब किसी ऐक्सिस (या सब-ऐक्सिस) का इस्तेमाल, एक से ज़्यादा टेंसर में नॉन-कॉरस्पॉन्डिंग डाइमेंशन (जैसे, मैटमैल में नॉन-कॉन्ट्रैक्टिंग डाइमेंशन) को शार्ड करने के लिए किया जाता है या जब कोई ऐक्सिस, एक टेंसर में डाइमेंशन को शार्ड करता है, लेकिन दूसरे टेंसर में कॉरस्पॉन्डिंग डाइमेंशन को शार्ड नहीं करता, तो कहा जाता है कि कार्रवाई में शार्डिंग से जुड़ा कोई टकराव है. इसलिए, इस पास के बाद, कार्रवाइयों में कोई टकराव नहीं होता.

यह पास, रीशार्ड कार्रवाइयों को साफ़ तौर पर इंजेक्ट करता है, ताकि हर कार्रवाई के लिए, कॉरस्पॉन्डिंग डाइमेंशन, सभी ऑपरेंड और नतीजों में एक ही तरीके से शार्ड किए जाएं. साथ ही, हर ऐक्सिस (या सब-ऐक्सिस) का इस्तेमाल, सिर्फ़ एक डाइमेंशन टाइप को शार्ड करने के लिए किया जा सके.

उदाहरण:

इनपुट:

mesh = <"x"=4, "y"=2>
%lhs : tensor<8x32xf32> {sdy.sharding=<@mesh, \[{"x"}, {"y"}\]>}
%rhs : tensor<32x16xf32> {sdy.sharding=<@mesh, \[{"y"}, {"x"}\]>}
stablehlo.dot %lhs, %rhs {sdy.sharding_per_value=<[<@mesh, \[{"x"}, {}\]>]>}
  : (tensor<8x32xf32>, tensor<32x16xf32>) -> tensor<8x16xf32>

आउटपुट:

sdy.mesh = <"x"=4, "y"=2>
%lhs : tensor<8x32xf32> {sdy.sharding=<@mesh, \[{"x"}, {"y"}\]>}
%rhs : tensor<32x16xf32> {sdy.sharding=<@mesh, \[{"y"}, {"x"}\]>}
%0 = sdy.reshard %rhs <@mesh, \[{"y"}, {}\]> : tensor<32x16xf32>
stablehlo.dot %lhs, %0 {sdy.sharding_per_value=<[<@mesh, \[{"x"}, {}\]>]>}
  : (tensor<8x32xf32>, tensor<32x16xf32>) -> tensor<8x16xf32>

ऊपर दिए गए उदाहरण में, lhs और rhs दोनों को उनके नॉन-कॉन्ट्रैक्टिंग डाइमेंशन पर "x" ऐक्सिस पर शार्ड किया गया है. यह काम नहीं करता. यह पास, डॉट कार्रवाई से पहले rhs पर साफ़ तौर पर रीशार्ड जोड़ता है, ताकि डॉट कार्रवाई में काम करने वाली शार्डिंग हो.

विकल्प

-enable-full-version                  : Enable full version.
-avoid-reshards-on-named-computations : Avoid explicit reshards/collectives on named computations.

-sdy-remove-all-gather-reduce-scatter-for-cmv1

_सीएमवी1 के लिए, sdy.all_gather और sdy.reducescatter को हटाता है.

ऑल-गैदर + डॉट पैटर्न में, ऑल-गैदर को हटाता है. डॉट + रिड्यूस-स्कैटर पैटर्न में, रिड्यूस-स्कैटर को हटाता है. यह पास, कलेक्टिव मैटमैल V1 (सीएमवी1) के साथ काम करने के लिए है. यह b/432019089 के लिए, अस्थायी समाधान है.

-sdy-remove-propagation-debug-info

एक्सपोर्ट के दौरान, प्रोपगेशन डीबग की जानकारी (प्रोपगेशन एज और ऑरिजिन शार्डिंग) को हटाता है.

-sdy-remove-sharding-groups

प्रोपगेशन के बाद, ShardingGroupOps को हटाता है.

-sdy-remove-sub-axes-in-input-output-shardings

इनपुट/आउटपुट शार्डिंग में सब-ऐक्सिस को हटाता है.

शार्डी के कुछ उपयोगकर्ता चाहते हैं कि फ़ंक्शन के इनपुट/आउटपुट में सब-ऐक्सिस के बिना शार्डिंग हो. यह पास, इनपुट/आउटपुट शार्डिंग से सब-ऐक्सिस और उनके ट्रेलिंग ऐक्सिस को हटाता है. यह पास आम तौर पर, sdy-update-non-divisible-input-output-shardings के बाद होता है, ताकि यह पक्का किया जा सके कि सब-ऐक्सिस को हटाने से, कोई नॉन-डिविज़िबल शार्डिंग न हो.

-sdy-reshard-to-collectives

ReshardOp को, शार्डी कलेक्टिव ऑप्स में बदलता है.

रीशार्ड ऑप्स को मैच करता है और उन्हें शार्डी कलेक्टिव ऑप्स में फिर से लिखता है. इस पास के बाद, मॉड्यूल में कोई रीशार्ड ऑप्स नहीं रहता.

अगर keepRedundantReshards की वैल्यू 'सही' है, तो सिर्फ़ रिडंडेंट रीशार्ड ऑप्स ही बचे रहते हैं. डिफ़ॉल्ट रूप से, यह मान लिया जाता है कि साफ़ तौर पर रीशार्ड पहले ही जोड़े जा चुके हैं (sdy-insert-explicit-reshards). साथ ही, यह रिडंडेंट रीशार्ड को नहीं रखता. अगर साफ़ तौर पर रीशार्ड पहले से नहीं जोड़े गए हैं, तो इसे रिडंडेंट रीशार्ड को रखना चाहिए.

उदाहरण:

इनपुट:

mesh = <"x"=2, "y"=2, "z"=2>
%0 : tensor<16x2xf32> {sdy.sharding<@mesh, \[{"x", "y", "z"}, {}\]>
%1 = sdy.reshard %arg0 <@mesh, \[{"x"}, {}\]> : tensor<16x2xf32>

आउटपुट:

mesh = <"x"=2, "y"=2, "z"=2>
%0 : tensor<16x2xf32> {sdy.sharding<@mesh, \[{"x", "y", "z"}, {}\]>
%1 = sdy.all_gather \[{"y", "z"}, {}\] %arg0 out_sharding=<@mesh, \[{"x"}, {}\]> : tensor<16x2xf32>

ऊपर दिए गए उदाहरण में, टेंसर %0 : tensor<16x2xf32> को \[{"x", "y", "z"}, {}\] के तौर पर शार्ड किया गया है. इसके बाद, reshard ऑप इसे \[{"x"}, {}\] के तौर पर रीशार्ड करता है. पहले ऐक्सिस पर, रीशार्ड के बाद सफ़िक्स {"y", "z"} हटा दिया जाता है . इससे हम यह अनुमान लगाते हैं कि हमने {"y", "z"} को ऑल-गैदर किया है. दूसरे डाइमेंशन में कोई बदलाव नहीं किया गया है.

विकल्प

-keep-redundant-reshards : Whether it keeps redundant reshards or removes.

-sdy-sharding-constraint-to-reshard

ShardingConstraintOp को ReshardOp में बदलता है.

-sdy-sink-data-flow-edges

सभी DataFlowEdgeOp को उनके इनपुट में सिंक करता है.

हर DataFlowEdgeOp की शार्डिंग को उसके इनपुट (एज का रूट टारगेट) में ले जाता है और ऑप को उसके इनपुट से बदल देता है.

विकल्प

-sink-debug-sharding-origins          : Whether to sink the debug sharding origins info. See `debug-sharding-origins` option in propagation for more info.
-sink-debug-propagation-edge-sharding : Whether to sink the debug propagation edge sharding info. See `debug-propagation-edge-sharding` option in propagation for more info.

-sdy-update-non-divisible-input-output-shardings

FuncOp के इनपुट/आउटपुट को बराबर-बराबर शार्ड करता है. इससे, नॉन-डिविज़िबल शार्डिंग की वजह से पैडिंग की ज़रूरत नहीं पड़ती.

शार्डी के उपयोगकर्ता चाहते हैं कि फ़ंक्शन के इनपुट/आउटपुट को बराबर-बराबर बांटा/शार्ड किया जा सके, ताकि उन्हें अपने टेंसर की पैडिंग न करनी पड़े. प्रोपगेशन की वजह से, इनपुट/आउटपुट में नॉन-डिविज़िबल शार्डिंग हो सकती है. इसलिए, यह पास उन्हें ओरिजनल शार्डिंग के सबसे बड़े डाइमेंशन शार्डिंग प्रीफ़िक्स में अपडेट करता है, जिसे बराबर-बराबर शार्ड किया गया है.