Operator Fusion
tokamax.ops.op_fusion की मदद से, आस-पास के JAX ऑपरेशन (प्रोलॉग और एपिलॉग) को सीधे Tokamax Pallas TPU कर्नेल में फ़्यूज़ किया जा सकता है. इसके लिए, JAX Pallas Fuser का इस्तेमाल किया जाता है.
नॉर्मलाइज़ेशन या ऐक्टिवेशन और कस्टम कर्नेल के बीच, इंटरमीडिएट ऐक्टिवेशन को एचबीएम में सेव करने के बजाय, फ़्यूज़ किए गए ऑपरेशन, कर्नेल लूप के अंदर हर टाइल पर वीएमईएम में चलते हैं.
@op_fusion.fuse का इस्तेमाल करना
बुनियादी इस्तेमाल (प्रोलॉग और एपिलॉग)
tokamax.ops से op_fusion इंपोर्ट करें और फ़्यूज़िबल टोकामाक्स ऑपरेटर वाले फ़ंक्शन को @op_fusion.fuse से रैप करें (आम तौर पर, @jax.jit के अंदर):
import jax
import jax.numpy as jnp
import tokamax
from tokamax.ops import op_fusion
def rms_norm(x: jax.Array, weight: jax.Array, eps: float = 1e-6) -> jax.Array:
ms = jnp.mean(jnp.square(x.astype(jnp.float32)), axis=-1, keepdims=True)
return (x.astype(jnp.float32) * jax.lax.rsqrt(ms + eps)).astype(
x.dtype
) * weight
@jax.jit
@op_fusion.fuse
def fused_ragged_dot(x, rms_weight, rhs, out_bias, group_sizes):
# Prologue: fused into the kernel's LHS tile load.
x_norm = rms_norm(x, rms_weight)
out = tokamax.ragged_dot(
x_norm,
rhs,
group_sizes=group_sizes,
implementation="mosaic_tpu_v2",
)
# Epilogue: fused into the kernel's output store.
return jax.nn.silu(out + out_bias)
आपके पास साफ़ तौर पर फ़्यूज़िबल लॉजिक (tokamax.ragged_dot(..., implementation="mosaic_tpu_v2")) के साथ हाई-लेवल फ़ंक्शनल एपीआई को कॉल करने का विकल्प होता है. इसके अलावा, सीधे तौर पर किसी खास tokamax.Op इंस्टेंस (जैसे, PallasMosaicTpuV2RaggedDot) को भी कॉल किया जा सकता है.
अगर @op_fusion.fuse के अंदर मौजूद कोई ऑपरेटर फ़्यूज़न के साथ काम नहीं करता है, तो Tokamax NotImplementedError को ट्रिगर करता है.
डेकोरेटर के विकल्प
op_fusion.fuse अपने कीवर्ड आर्ग्युमेंट को jax.experimental.pallas.fuser.fuse पर फ़ॉरवर्ड करता है:
@op_fusion.fuse(
resolve_fusion_dtypes=True,
debug=False,
strict_mode=True,
static_argnums=None,
static_argnames=None,
)
static_argnums/static_argnames: फ़्यूज़ किए गए फ़ंक्शन को कॉल करते समय, नॉन-ऐरे Python आर्ग्युमेंट (उदाहरण के लिए, स्केलर कॉन्फ़िगरेशन वैल्यू या बूलियन फ़्लैग) को स्टैटिक के तौर पर मार्क करें.debug=True: यह ट्रेस किए गए फ़्यूज़न jaxprs को प्रिंट करता है. इससे यह पता लगाने में मदद मिलती है कि कोई ऑपरेशन फ़्यूज़ क्यों नहीं हुआ या ब्लॉक-स्पेक्ट्रम प्रोपेगेशन क्यों नहीं हुआ.strict_mode: यह Pallas Fuser के सख्त ब्लॉक-स्पेक्ट्रम के बराबर होने की जांच को कंट्रोल करता है.
क्वांटाइज़्ड इनपुट और पहले से मौजूद कर्नेल ऐक्टिवेशन
फ़्यूज़्ड प्रोलॉग, ऑन-द-फ़्लाई ऐक्टिवेशन क्वांटाइज़ेशन (AsQArray), पहले से क्वांटाइज़ किए गए वेट (qwix.QArray), और PallasMosaicTpuV2RaggedDot पर पहले से मौजूद फ़्यूज़्ड गेट/अप ऐक्टिवेशन के साथ कंपोज़ होते हैं:
import jax
import jax.numpy as jnp
import qwix
from tokamax._src import quantization
from tokamax._src.ops.ragged_dot import pallas_mosaic_tpu_v2
from tokamax.ops import op_fusion
gmm_op = pallas_mosaic_tpu_v2.PallasMosaicTpuV2RaggedDot()
@op_fusion.fuse
def fused_rms_norm_gate_up(x, rms_weight, w_q, w_scale, group_sizes):
x_norm = rms_norm(x, rms_weight)
return gmm_op(
quantization.AsQArray(x_norm, jnp.float8_e4m3fn),
qwix.QArray(w_q, w_scale),
group_sizes=group_sizes,
zero_initialize=False,
fuse_gateup_activation="silu",
preferred_element_type=jnp.bfloat16,
)
हर @op_fusion.fuse ब्लॉक के लिए एक फ़्यूज़िबल ऑप
JAX Pallas Fuser, हर @op_fusion.fuse स्कोप के लिए सिर्फ़ एक फ़्यूज़िबल कर्नेल के साथ काम करता है.
एक से ज़्यादा कर्नल को चेन करते समय (उदाहरण के लिए, एमओई ब्लॉक में gate_up के बाद down), हर फ़्यूज़िबल स्टेज को बाहरी @jax.jit के अंदर उसके अपने @op_fusion.fuse फ़ंक्शन में रैप करें:
@jax.jit
def moe_layer(x, rms_weight, w1_q, w1_scale, w2_q, w2_scale, group_sizes):
mid = fused_rms_norm_gate_up(x, rms_weight, w1_q, w1_scale, group_sizes)
return gmm_op(
quantization.AsQArray(mid, jnp.float8_e4m3fn),
qwix.QArray(w2_q, w2_scale),
group_sizes=group_sizes,
zero_initialize=False,
preferred_element_type=jnp.bfloat16,
)
@jax.custom_vjp के साथ ऑटोमैटिक डिफ़रेंशिएशन
@op_fusion.fuse, फ़ॉरवर्ड कंप्यूटेशन ब्लॉक को फ़्यूज़ करता है. साथ ही, jax.grad के ज़रिए फ़्यूज़ किए गए बैकवर्ड पास को अपने-आप सिंथेसाइज़ नहीं करता. किसी फ़्यूज़्ड ब्लॉक को अलग करते समय, फ़ॉरवर्ड और बैकवर्ड कॉल को साफ़ तौर पर @jax.custom_vjp में रैप करें. इससे, प्रोलॉग/एपिलॉग को फ़ॉरवर्ड और बैकवर्ड (drhs / dlhs) कर्नेल में अलग-अलग फ़्यूज़ किया जा सकता है:
import jax
from tokamax._src.ops.ragged_dot import pallas_mosaic_tpu_v2
from tokamax.ops import op_fusion
op = pallas_mosaic_tpu_v2.PallasMosaicTpuV2RaggedDot()
drhs_op = pallas_mosaic_tpu_v2.PallasMosaicTpuV2RaggedDot(
num_actual_groups=num_groups
)
@op_fusion.fuse
def fused_fwd_kernel(x, w, r, group_sizes):
return op(rms_norm(x, w), r, group_sizes=group_sizes, zero_initialize=True)
@op_fusion.fuse
def fused_drhs_kernel(x, w, dy, group_sizes):
return drhs_op(
rms_norm(x, w),
dy,
group_sizes=group_sizes,
ragged_dot_dimension_numbers=pallas_mosaic_tpu_v2.DRHS_RAGGED_DOT_DIM_NUMS,
preferred_element_type=dy.dtype,
)
@jax.custom_vjp
def fused_gmm(x, w, r, group_sizes):
return fused_fwd_kernel(x, w, r, group_sizes)
def fused_gmm_fwd(x, w, r, group_sizes):
return fused_fwd_kernel(x, w, r, group_sizes), (x, w, r, group_sizes)
def fused_gmm_bwd(residuals, dy):
x, w, r, group_sizes = residuals
dr = fused_drhs_kernel(x, w, dy, group_sizes)
dx_norm = op(
dy,
r,
group_sizes=group_sizes,
ragged_dot_dimension_numbers=pallas_mosaic_tpu_v2.DLHS_RAGGED_DOT_DIM_NUMS,
zero_initialize=True,
)
_, rms_vjp = jax.vjp(rms_norm, x, w)
dx, dw = rms_vjp(dx_norm)
return dx, dw, dr, None
fused_gmm.defvjp(fused_gmm_fwd, fused_gmm_bwd)
Bare Fusible Kernels का इस्तेमाल करना
पुराने सिस्टम के साथ काम करने की सुविधा को बनाए रखने के लिए, Tokamax ऑपरेटर रैपर (tokamax.ragged_dot या PallasMosaicTpuV2RaggedDot) के साथ @op_fusion.fuse को प्राथमिकता दें. इसके लिए, बेयर फ़्यूज़िबल कर्नेल और @jax.experimental.pallas.fuser.fuse का इस्तेमाल न करें. साथ ही, इनपुट कैनोनिकलाइज़ेशन, ऑटोट्यूनिंग, और मेटाडेटा सीरियलाइज़ेशन को बनाए रखें. अगर लो-लेवल gmm_v2 / tgmm_v2 कर्नेल को सीधे तौर पर शुरू किया जाता है, तो @op_fusion.fuse या @jax.experimental.pallas.fuser.fuse में gmm_fuser.gmm_v2_fusible या gmm_fuser.tgmm_v2_fusible का इस्तेमाल करें:
from jax.experimental.pallas import fuser
from tokamax._src.ops.gmm_v2 import gmm_fuser
@jax.jit
@fuser.fuse
def fused_bare_gmm(x, w, rhs, out_bias, group_sizes):
out = gmm_fuser.gmm_v2_fusible(rms_norm(x, w), rhs, group_sizes)
return jax.nn.silu(out + out_bias)
जब gmm_v2_fusible / tgmm_v2_fusible के आस-पास कोई प्रोलॉग या एपिलॉग ऑप नहीं होता, तब मामूली 0-इक्वेशन वाले फ़्यूज़न अनरैप हो जाते हैं. इससे कंपाइल किया गया कर्नेल, बिना फ़्यूज़ किए गए पाथ को अपनाता है.
इस्तेमाल किए जा सकने वाले ऑपरेशन और पाबंदियां
- फ़िलहाल, Tokamax के ये ऑपरेशंस इस्तेमाल किए जा सकते हैं:
PallasMosaicTpuV2RaggedDot(implementation="mosaic_tpu_v2", इसमें फ़ॉरवर्ड/dlhsgmm_v2और drhstgmm_v2, दोनों शामिल हैं). - इस्तेमाल किए जा सकने वाले प्रोलॉग / एपिलॉग JAX प्रिमिटिव: इन्हें JAX Pallas Fuser मैनेज करता है.
आम तौर पर इस्तेमाल किए जाने वाले ऑप्स में, पॉइंटवाइज़ यूनरी/बाइनरी मैथ,
select/clamp, dtype कास्ट,broadcast_in_dim,transpose,concatenate/stack/split, और पूरे ब्लॉक ऐक्सिस (जैसे,RMSNorm) परreduce_sumशामिल हैं. फ़्यूज़र ब्लॉक-स्पेक नियमों के बिना ऑप्स—जैसे किlax.pad, कंट्रोल फ़्लो (scan/while/cond), औरreduce_max/reduce_min—को फ़्यूज़ नहीं किया जा सकता. PallasMosaicTpuV2RaggedDotफ़्यूज़न से जुड़ी पाबंदियां:size_mको टीपीयू सबलेन टाइलिंग (size_lhs_sublane) के साथ अलाइन किया जाना चाहिए. ऐसा तब करना चाहिए, जबlhsयाoutकोgmm_v2में फ़्यूज़ किया गया हो. साथ ही, जबlhsयाrhsकोtgmm_v2में फ़्यूज़ किया गया हो.outको फ़्यूज़ करने पर,out_size_n(औरtgmm_v2के लिएsize_k) कोnum_lanes(128) / टाइल साइज़ के हिसाब से अलाइन किया जाना चाहिए. साथ ही, सिर्फ़ सिंगल-आउटपुट एपिलॉग का इस्तेमाल किया जा सकता है.partial_sum, फ़्यूज़न के साथ काम नहीं करता.gmm_v2में फ़्यूज़ किए गएrhsका इस्तेमाल,fuse_actया सब-बाइट पैक किए गए वेट के साथ नहीं किया जा सकता.
फ़्यूज़न के साथ काम करने वाला कर्नेल और Op बनाना
आर्किटेक्चर की खास जानकारी
फ़्यूज़न डिस्पैच को पब्लिक फ़साड, इंटरनल अडैप्टर, Op क्लास, और कर्नल के कंपैनियन फ़्यूज़र मॉड्यूल के बीच बांटा गया है:
tokamax/ops/op_fusion.pyfuseको सार्वजनिक एंट्री पॉइंट के तौर पर फिर से एक्सपोर्ट करता है.tokamax._src.ops.fuser_adapterjax.experimental.pallas.fuser.fuseके आस-पास, JAX उपयोगकर्ता के लिए जानकारी वाला फ़्लैग (in_op_fusion_context()) सेट करता है.- जब
Op.__call__उस कॉन्टेक्स्ट में चलता है, तो यह जांच करता है कि सबक्लास,_fusible_fwdको बदलता है या नहीं. अगर नहीं, तोNotImplementedErrorको रेज़ करता है औरfuser_adapter.call_fusible_opको डेलिगेट करता है. call_fusible_op,bound_args.default_configको रिज़ॉल्व करते समय फ़्यूज़न कॉन्टेक्स्ट को निलंबित कर देता है. साथ ही, अरे लीव परfuser.fusibleप्रिमिटिव को बाइंड करता है,Op.fusible_argnamesमें शामिल नहीं किए गए किसी भी आर्ग्युमेंट को मटीरियलाइज़ करता है, औरbound_args._tokamax_metadata(config)मेंOp._fusible_fwd(*args, out_fusions=out_fusions, config=config, **kwargs)को शुरू करता है.
पहला चरण: अपने Op पर fusible_argnames को डिक्लेयर करना और _fusible_fwd को ओवरराइड करना
अपने बैकएंड Op सबक्लास पर (पूरी जानकारी के लिए
PallasMosaicTpuV2RaggedDot
देखें):
fusible_argnamesको उन पैरामीटर के नामों पर सेट करें जिनकी अरे लीव,fuser.Fusionक्लोज़र के तौर पर रहनी चाहिए. अन्य सभी अरे आर्ग्युमेंट (जैसे, मेटाडेटा, इंडेक्स याgroup_sizes) कोcall_fusible_op,_fusible_fwdके चलने से पहले, सामान्यjax.Arrayमें अपने-आप बदल देता है._fusible_fwdको बदलें._fwd(जो(out, residuals)दिखाता है) के उलट,_fusible_fwdसीधे तौर पर आउटपुटTदिखाता है. साथ ही,out_fusionsऔर रिज़ॉल्व किया गयाconfigदिखाता है.- कंपोज़िट PyTree ऑपरेंड के लिए, जिनकी लीफ़ को फ़्यूज़ नहीं किया जाना चाहिए (उदाहरण के लिए, पहले से क्वांटाइज़ किए गए
QArray(qvalue, scale)वेट), उन्हेंfuser_adapter.materialize(...)के साथ साफ़ तौर पर मटीरियलाइज़ करें.
from typing import ClassVar, override
import jax
from tokamax._src.ops import fuser_adapter
class MyPallasTpuOp(MyBaseOp[Config, None]):
config_cls: ClassVar[type[Config]] = Config
fusible_argnames: ClassVar[tuple[str, ...]] = ("lhs", "rhs")
@override
def _fusible_fwd(
self,
lhs: jax.Array | fuser_adapter.InputFusion,
rhs: jax.Array | fuser_adapter.InputFusion,
*,
out_fusions: fuser_adapter.OutputFusion | None = None,
config: Config,
**kwargs,
) -> jax.Array:
return my_kernel_fusible(
lhs, rhs, config=config, out_fusions=out_fusions, **kwargs
)
दूसरा चरण: Fuser इंटिग्रेशन को कंपैनियन *_fuser.py मॉड्यूल में रखना
Tokamax के कोर कर्नेल (gmm_v2.py, tgmm_v2.py) और इसके फ़्यूज़र इंटिग्रेशन (gmm_fuser.py) के बीच के अंतर को समझें:
jax.experimental.pallas.fuserइंपोर्ट को कोर कर्नेल फ़ाइल से बाहर रखें, ताकि अनफ़्यूज़्ड कर्नेल अपने-आप में पूरा रहे और उसे आसानी से पढ़ा जा सके.फ़्यूज़न स्पेक बनाने से पहले, 0-इक्वेशन वाले ट्रिवियल
fuser.Fusionक्लोज़र को अनरैप करें:def _unwrap_trivial_input_fusion(x): if isinstance(x, fuser.Fusion) and not jax.make_jaxpr(x)().jaxpr.eqns: return x() return xfuser.fusible, हर इनपुट कलेक्शन लीफ़ कोFusionमें रैप करता है. भले ही, उस ऑपरेंड में कोई प्रोड्यूसर ऑप न हो. ट्रिवियल क्लोज़र को अनरैप करने से, बिना बदलाव किए गए अनफ़्यूज़्डBlockSpecपाथ पर, बिना छुए गए ऑपरेंड बने रहते हैं. साथ ही, रनटाइम ओवरहेड भी शून्य रहता है.अगर आपके बेस कर्नेल को
@jax.jitसे सजाया गया है, तो फ़्यूज़िबल पाथ परinspect.unwrap(base_kernel)को कॉल करें—@jax.jit,fuser.Fusionआर्ग्युमेंट को अस्वीकार करता है.अगर बेयर-कर्नेल कॉलर को भी
@fuser.fuseमें सीधे तौर पर आपके फ़्यूज़िबल एंट्रीपॉइंट को शुरू करने की अनुमति देनी है, तो बेयरjax.Arrayकॉल का पता लगाएं औरfuser.fusibleको अपने-आप बाइंड करें (जैसा किgmm_fuser.gmm_v2_fusibleकरता है).
तीसरा चरण: फ़्यूज़न को अनपैक करें और fuser_adapter की मदद से BlockSpec को ट्रांसफ़ॉर्म करें
लो-लेवल fuser एपीआई को सीधे कॉल करने के बजाय,
tokamax._src.ops.fuser_adapter
में शेयर किए गए हेल्पर का इस्तेमाल करें:
इनपुट प्रोलॉग को अनपैक करना:
lhs_fn, lhs_values, lhs_values_type = fuser_adapter.unpack_input_fusion(lhs)(fn, values, values_type)दिखाता है, जहांvalues, प्रोलॉग से बंद किए गए एचबीएम अरे का ट्यूपल है औरvalues_typeमें उनकेShapeDtypeStructमौजूद हैं.सिंगल-आउटपुट एपिलॉग को अनपैक करना:
out_fn, out_values, out_values_type, out_init = ( fuser_adapter.unpack_output_fusion(out_fusions, raw_out_type) )यह Pallas Fuser के 1-टपल आउटपुट कन्वेंशन को एक
ShapeDtypeStruct(out_init) में अनरैप करता है. साथ ही, कई आउटपुट वाले एपिलॉग परNotImplementedErrorको बढ़ाता है.प्रोलॉग की मदद से, इनपुट
BlockSpecको पीछे की ओर खींचना:pulled_lhs_fn, lhs_val_specs = fuser_adapter.pull_input_spec( lhs_fn, lhs_spec, lhs_values_type, grid_len=grid_len, num_scalar_prefetch=0, )एपिलॉग की मदद से, आउटपुट
BlockSpecको पुश और पुल करना:pulled_out_fn, out_fusion_input_specs, final_out_spec = ( fuser_adapter.push_pull_block_spec( out_fn, out_spec, out_values_type, raw_out_type, grid_len=grid_len, num_scalar_prefetch=0, ) )fuser_adapter.push_pull_block_spec, साइज़-1 ब्रॉडकास्ट के साथ शेप-प्रिज़र्विंग रिडक्शन को हैंडल करता है. जैसे,RMSNormएपिलॉग जो रॉfuser.push_block_specको ट्रिप करते हैं. यह पुष्टि करता है कि पुल की गई जानकारी, कर्नेल के लिखे गएout_specसे मेल खाती है. साथ ही, 1-टपल रिटर्न वैल्यू को अनरैप करता है और JAX के साथ काम करने वाले वर्शन के साथ काम करता है.
चौथा चरण: Pallas Kernel में, पुल किए गए स्पेक्स और कॉलबैक को वायर करना
- कैप्चर किए गए एचबीएम इनपुट के साथ-साथ, पुल किए गए
BlockSpecs को पास करें:- इनपुट प्रोलॉग
valuesराइड, फ़्यूज़्ड ऑपरेंड (lhs_val_specsके साथ जोड़ा गया) की जगह पर. - आउटपुट एपिलॉग साइड इनपुट (
out_values, जैसे कि एपिलॉग बायस या रेज़िड्यूअल) को रीड-ओनली एचबीएम कर्नेल इनपुट के तौर पर पास किया जाता है. इन्हेंout_fusion_input_specsके साथ जोड़ा जाता है, ताकिpltpu.emit_pipelineउनकी टाइल को वीएमईएम में पहले से फ़ेच कर सके. अनफ़्यूज़ होने पर, रेफ़रंस और स्पेसिफ़िकेशन (0 PyTree लीफ़), दोनों के लिए एक खाली ट्यूपल()पास करें.
- इनपुट प्रोलॉग
- हर फ़्यूज़न मोड के लिए अलग-अलग PyTree टाइप इस्तेमाल करें:
pltpu.emit_pipeline,jax.tree.map(..., in_specs, in_refs)को मैप करता है. इसलिए, हर इनपुट रेफ़रंस कंटेनर और उसकेin_specकंटेनर का@jax.tree_util.register_dataclassPyTree टाइप बिलकुल एक जैसा होना चाहिए. उदाहरण के लिए, अनफ़्यूज़्डlhsके लिएLhsRef[T]और प्रोलॉग-फ़्यूज़्डlhsके लिएFusedLhsRef[T].
कर्नेल बॉडी में मौजूद वीएमईएम टाइल पर, पुल किए गए कॉलबैक का आकलन करना:
- पुल किए गए हर फ़ंक्शन का सिग्नेचर
fn(program_ids, scalar_prefetch, *args)होता है. pltpu.emit_pipeline(..., _explicit_indices=True)में,pids = step.index(नहीं तोtuple(pl.program_id(i) for i in range(grid_len))) और()पास करें, जबnum_scalar_prefetch=0:
# Prologue: compute the input tile from prefetched VMEM refs. tiled_lhs = lhs_fn(pids, (), tuple(r[...] for r in lhs_val_refs)) # Epilogue: transform the accumulated output tile before storing. out_vals = tuple(r[...] for r in tiled_out_fusion_input_refs) out_tile = out_fn(pids, (), out_vals, acc_tile)- पुल किए गए हर फ़ंक्शन का सिग्नेचर
आम तौर पर होने वाली गलतियां
pl.BoundedSliceऔरreshape: Pallas Fuser का रीशेप पुल नियम,pl.BoundedSliceको अस्वीकार करता है. अगर आपका अनफ़्यूज़्ड कर्नेल,emit_pipelineसे पहले 2D एचबीएम इनपुट को 3D सबलेन-टाइल किए गए रेफ़रंस में बदलता है, तो फ़्यूज़्ड ऑपरेंड के ज़रिए पुल या पुश करने से पहले, स्पेक को 2DBlockSpec((pl.BoundedSlice(tile_m), col_dim), ...)में बदलें. इसके बारे में ज़्यादा जानने के लिए,gmm_fuser.pyमें_to_2d_bounded_specदेखें.- लाइन मास्किंग के साथ एपिलॉग ऑर्डर करना: अगर आपका कर्नेल, ग्रुप से बाहर की या पैडिंग लाइनों को शून्य पर मास्क करता है और अलग-अलग चरणों में आंशिक सबलेन टाइल को जोड़ता है, तो शून्य मास्क लागू करने से पहले
out_fnचलाएं, ताकि शून्य से ज़्यादा वैल्यू वाले एपिलॉग (जैसे,+ bias) मास्क की गई लाइनों को खराब न करें. pl.kernelwithSequenceout_type:pl.kernel,tupleयाlistout_typeको कई पोज़िशनलout_refआर्ग्युमेंट में अनपैक करता है.fuser_adapter.unpack_output_fusionका इस्तेमाल करने से, सिंगल-आउटपुटout_initको सिर्फ़ShapeDtypeStructके तौर पर रखा जाता है.- होस्ट-साइड पैडिंग बनाम फ़्यूज़ किए गए शेप: Pallas Fuser में
lax.padनियम या अलाइन नहीं किए गएlax.sliceपुश/पुल नियम नहीं होते हैं. इसलिए, अपने फ़्यूज़न स्पेक केprepare()तरीके में अलाइनमेंट की ज़रूरी शर्तों की पुष्टि करें. साथ ही,Fusionऑब्जेक्ट को पैड करने के बजाय, काम न करने वाले शेप के लिएNotImplementedErrorको बढ़ाएं. _fusible_fwdके अंदर हेल्परOps:call_fusible_op,default_configरिज़ॉल्यूशन के दौरान और_fusible_fwdके अंदर निलंबित हो जाता हैin_op_fusion_context(). इसलिए,_fusible_fwdके अंदर अनफ़्यूज़्ड हेल्परOpको कॉल करने से, नेस्टेड फ़्यूज़न गड़बड़ियों को ट्रिगर किए बिना, इसका सामान्य_fwdपाथ चलता है .
टेस्टिंग के लिए चेकलिस्ट
किसी ऑपरेटर के लिए फ़्यूज़न की सुविधा जोड़ते समय, इन बातों का ध्यान रखें:
- प्रोलॉग फ़्यूज़न (पॉइंटवाइज़ और फ़ुल-ऐक्सिस रिडक्शन, जैसे कि
RMSNorm), एपिलॉग फ़्यूज़न (बायस या रेज़िड्यूअल जैसे बाहरी साइड इनपुट के साथ और उनके बिना), और प्रोलॉग + एपिलॉग का कॉम्बिनेशन. - फ़्यूज़न न होने पर समानता: पुष्टि करें कि फ़्यूज़ किए जा सकने वाले एंट्रीपॉइंट को कॉल करने पर, बिटवाइज़-आइडेंटिकल आउटपुट (
chex.assert_trees_all_equal) जनरेट होता है. इसके लिए, आस-पास के किसी भी ऑप (प्लेन,@op_fusion.fuse, और@fuser.fuse) का इस्तेमाल न करें. यह आउटपुट, अनफ़्यूज़्ड कर्नेल के लिए जनरेट होता है. - एक्सप्लिसिट
@jax.custom_vjpग्रेडिएंट: पुष्टि करें कि फ़ॉरवर्ड वैल्यू और ग्रेडिएंट, अनफ़्यूज़्ड रेफ़रंस से मैच करते हों. - इस्तेमाल न किए जा सकने वाले कॉम्बिनेशन: अलाइन न किए गए शेप या काम न करने वाले कर्नेल विकल्पों के लिए,
NotImplementedErrorमैसेज की पुष्टि करें.
रेफ़रंस के तौर पर लागू करना
- सार्वजनिक फ़साड:
tokamax/ops/op_fusion.py Opडिस्पैच और शेयर किए गए हेल्पर:tokamax/_src/ops/fuser_adapter.py- कर्नेल फ़्यूज़र इंटिग्रेशन (
GmmFusionSpec/TgmmFusionSpec):tokamax/_src/ops/gmm_v2/gmm_fuser.py Op._fusible_fwdइंटिग्रेशन:tokamax/_src/ops/ragged_dot/pallas_mosaic_tpu_v2.py- कर्नेल और
Opफ़्यूज़न टेस्ट:tokamax/_src/ops/gmm_v2/gmm_fuser_test.pyऔरtokamax/_src/ops/ragged_dot/pallas_mosaic_tpu_v2_test.py