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", इसमें फ़ॉरवर्ड/dlhs gmm_v2 और drhs tgmm_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 क्लास, और कर्नल के कंपैनियन फ़्यूज़र मॉड्यूल के बीच बांटा गया है:

  1. tokamax/ops/op_fusion.py fuse को सार्वजनिक एंट्री पॉइंट के तौर पर फिर से एक्सपोर्ट करता है.
  2. tokamax._src.ops.fuser_adapter jax.experimental.pallas.fuser.fuse के आस-पास, JAX उपयोगकर्ता के लिए जानकारी वाला फ़्लैग (in_op_fusion_context()) सेट करता है.
  3. जब Op.__call__ उस कॉन्टेक्स्ट में चलता है, तो यह जांच करता है कि सबक्लास, _fusible_fwd को बदलता है या नहीं. अगर नहीं, तो NotImplementedError को रेज़ करता है और fuser_adapter.call_fusible_op को डेलिगेट करता है.
  4. 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 देखें):

  1. fusible_argnames को उन पैरामीटर के नामों पर सेट करें जिनकी अरे लीव, fuser.Fusion क्लोज़र के तौर पर रहनी चाहिए. अन्य सभी अरे आर्ग्युमेंट (जैसे, मेटाडेटा, इंडेक्स या group_sizes) को call_fusible_op, _fusible_fwd के चलने से पहले, सामान्य jax.Array में अपने-आप बदल देता है.
  2. _fusible_fwd को बदलें. _fwd (जो (out, residuals) दिखाता है) के उलट, _fusible_fwd सीधे तौर पर आउटपुट T दिखाता है. साथ ही, out_fusions और रिज़ॉल्व किया गया config दिखाता है.
  3. कंपोज़िट 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 x
    

    fuser.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 में, पुल किए गए स्पेक्स और कॉलबैक को वायर करना

  1. कैप्चर किए गए एचबीएम इनपुट के साथ-साथ, पुल किए गए BlockSpecs को पास करें:
    • इनपुट प्रोलॉग values राइड, फ़्यूज़्ड ऑपरेंड (lhs_val_specs के साथ जोड़ा गया) की जगह पर.
    • आउटपुट एपिलॉग साइड इनपुट (out_values, जैसे कि एपिलॉग बायस या रेज़िड्यूअल) को रीड-ओनली एचबीएम कर्नेल इनपुट के तौर पर पास किया जाता है. इन्हें out_fusion_input_specs के साथ जोड़ा जाता है, ताकि pltpu.emit_pipeline उनकी टाइल को वीएमईएम में पहले से फ़ेच कर सके. अनफ़्यूज़ होने पर, रेफ़रंस और स्पेसिफ़िकेशन (0 PyTree लीफ़), दोनों के लिए एक खाली ट्यूपल () पास करें.
  2. हर फ़्यूज़न मोड के लिए अलग-अलग PyTree टाइप इस्तेमाल करें:
    • pltpu.emit_pipeline, jax.tree.map(..., in_specs, in_refs) को मैप करता है. इसलिए, हर इनपुट रेफ़रंस कंटेनर और उसके in_spec कंटेनर का @jax.tree_util.register_dataclass PyTree टाइप बिलकुल एक जैसा होना चाहिए. उदाहरण के लिए, अनफ़्यूज़्ड lhs के लिए LhsRef[T] और प्रोलॉग-फ़्यूज़्ड lhs के लिए FusedLhsRef[T].
  3. कर्नेल बॉडी में मौजूद वीएमईएम टाइल पर, पुल किए गए कॉलबैक का आकलन करना:

    • पुल किए गए हर फ़ंक्शन का सिग्नेचर 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 सबलेन-टाइल किए गए रेफ़रंस में बदलता है, तो फ़्यूज़्ड ऑपरेंड के ज़रिए पुल या पुश करने से पहले, स्पेक को 2D BlockSpec((pl.BoundedSlice(tile_m), col_dim), ...) में बदलें. इसके बारे में ज़्यादा जानने के लिए, gmm_fuser.py में _to_2d_bounded_spec देखें.
  • लाइन मास्किंग के साथ एपिलॉग ऑर्डर करना: अगर आपका कर्नेल, ग्रुप से बाहर की या पैडिंग लाइनों को शून्य पर मास्क करता है और अलग-अलग चरणों में आंशिक सबलेन टाइल को जोड़ता है, तो शून्य मास्क लागू करने से पहले out_fn चलाएं, ताकि शून्य से ज़्यादा वैल्यू वाले एपिलॉग (जैसे, + bias) मास्क की गई लाइनों को खराब न करें.
  • pl.kernel with Sequence out_type: pl.kernel, tuple या list out_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 पाथ चलता है .

टेस्टिंग के लिए चेकलिस्ट

किसी ऑपरेटर के लिए फ़्यूज़न की सुविधा जोड़ते समय, इन बातों का ध्यान रखें:

  1. प्रोलॉग फ़्यूज़न (पॉइंटवाइज़ और फ़ुल-ऐक्सिस रिडक्शन, जैसे कि RMSNorm), एपिलॉग फ़्यूज़न (बायस या रेज़िड्यूअल जैसे बाहरी साइड इनपुट के साथ और उनके बिना), और प्रोलॉग + एपिलॉग का कॉम्बिनेशन.
  2. फ़्यूज़न न होने पर समानता: पुष्टि करें कि फ़्यूज़ किए जा सकने वाले एंट्रीपॉइंट को कॉल करने पर, बिटवाइज़-आइडेंटिकल आउटपुट (chex.assert_trees_all_equal) जनरेट होता है. इसके लिए, आस-पास के किसी भी ऑप (प्लेन, @op_fusion.fuse, और @fuser.fuse) का इस्तेमाल न करें. यह आउटपुट, अनफ़्यूज़्ड कर्नेल के लिए जनरेट होता है.
  3. एक्सप्लिसिट @jax.custom_vjp ग्रेडिएंट: पुष्टि करें कि फ़ॉरवर्ड वैल्यू और ग्रेडिएंट, अनफ़्यूज़्ड रेफ़रंस से मैच करते हों.
  4. इस्तेमाल न किए जा सकने वाले कॉम्बिनेशन: अलाइन न किए गए शेप या काम न करने वाले कर्नेल विकल्पों के लिए, NotImplementedError मैसेज की पुष्टि करें.

रेफ़रंस के तौर पर लागू करना