การรวมโอเปอเรเตอร์

tokamax.ops.op_fusion ช่วยให้คุณรวมการดำเนินการ JAX โดยรอบ (บทนำและบทส่งท้าย) เข้ากับเคอร์เนล Tokamax Pallas TPU ที่รวมได้โดยตรงผ่าน JAX Pallas Fuser แทนที่จะทำให้การเปิดใช้งานระดับกลางเป็นรูปเป็นร่างเป็น HBM ระหว่างการปรับมาตรฐานหรือการเปิดใช้งานกับเคอร์เนลที่กำหนดเอง การดำเนินการที่รวมกันจะทำงานใน VMEM บนแต่ละไทล์ภายในลูปเคอร์เนล

กำลังใช้ @op_fusion.fuse

การใช้งานพื้นฐาน (บทนำและบทส่งท้าย)

นำเข้า op_fusion จาก tokamax.ops และรวมฟังก์ชันที่มีโอเปอเรเตอร์ Tokamax ที่หลอมรวมได้ด้วย @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)

คุณสามารถเรียกใช้ API ฟังก์ชันระดับสูงที่มีการติดตั้งใช้งานแบบรวมที่ชัดเจน (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

อินพุตที่ผ่านการทำ Quantization และการเปิดใช้งานเคอร์เนลในตัว

บทนำแบบรวมจะประกอบด้วยการควอนไทซ์การเปิดใช้งานแบบเรียลไทม์ (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,
  )

Fusible Op 1 รายการต่อบล็อก @op_fusion.fuse

JAX Pallas Fuser รองรับเคอร์เนลที่รวมได้รายการเดียวต่อขอบเขต @op_fusion.fuse เมื่อเชื่อมโยงเคอร์เนลหลายรายการ (เช่น gate_up ตามด้วย down ในบล็อก MoE) ให้รวมแต่ละระยะที่รวมได้ไว้ในฟังก์ชัน @op_fusion.fuse ของตัวเองภายใน @jax.jit ด้านนอก

@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,
  )

Automatic Differentiation with Explicit @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 Kernel

ใช้ @op_fusion.fuse กับ Wrapper โอเปอเรเตอร์ Tokamax (tokamax.ragged_dot หรือ PallasMosaicTpuV2RaggedDot) แทนเคอร์เนลแบบฟิวส์เปล่าและ @jax.experimental.pallas.fuser.fuse เพื่อรักษาความเข้ากันได้แบบย้อนหลัง รวมถึงคงการแปลงรูปแบบอินพุตให้เป็นมาตรฐาน การปรับแต่งอัตโนมัติ และการจัดรูปแบบข้อมูลเมตาเป็นอนุกรม หากคุณเรียกใช้เคอร์เนล gmm_v2 / tgmm_v2 ระดับต่ำโดยตรง ให้ใช้ gmm_fuser.gmm_v2_fusible หรือ gmm_fuser.tgmm_v2_fusible ภายใน @op_fusion.fuse หรือ @jax.experimental.pallas.fuser.fuse ดังนี้

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" ครอบคลุมทั้ง forward/dlhs gmm_v2 และ drhs tgmm_v2)
  • พรีมิติฟ JAX ของ Prologue/Epilogue ที่รองรับ: ควบคุมโดย JAX Pallas Fuser การดำเนินการที่รองรับโดยทั่วไป ได้แก่ คณิตศาสตร์แบบ Unary/Binary แบบ Pointwise, select/clamp, การแคสต์ dtype, broadcast_in_dim, transpose, concatenate/stack/split และ reduce_sum ในแกนบล็อกทั้งหมด (เช่น RMSNorm) การดำเนินการที่ไม่มีกฎข้อกำหนดบล็อกของ Fuser เช่น lax.pad, โฟลว์การควบคุม (scan/while/cond) และ reduce_max/reduce_min ไม่สามารถ รวมเข้าด้วยกันได้
  • ข้อจำกัดของฟิวชัน PallasMosaicTpuV2RaggedDot
    • size_m ต้องสอดคล้องกับการจัดเรียงย่อยของ TPU (size_lhs_sublane) เมื่อ lhs หรือ out หลอมรวมใน gmm_v2 (และเมื่อ lhs หรือ rhs หลอมรวมใน tgmm_v2)
    • เมื่อรวม out แล้ว out_size_n (และ size_k สำหรับ tgmm_v2) ต้องสอดคล้องกับ num_lanes (128) / ขนาดไทล์ และรองรับเฉพาะ Epilogue เอาต์พุตเดียวเท่านั้น
    • ไม่รองรับ partial_sum กับฟิวชัน
    • ไม่รองรับ rhs ที่รวมอยู่ใน gmm_v2 ร่วมกับ fuse_act หรือน้ำหนักที่แพ็กเป็นซับไบต์

การเขียนเคอร์เนลและ Op ที่เข้ากันได้กับ Fusion

ภาพรวมสถาปัตยกรรม

การส่ง Fusion จะแบ่งออกเป็นส่วนหน้าสาธารณะ, อะแดปเตอร์ภายใน, คลาส Op และโมดูล Fuser ที่เป็นคู่หูของเคอร์เนล ดังนี้

  1. tokamax/ops/op_fusion.py ส่งออก fuse ซ้ำเป็นจุดแรกเข้าสาธารณะ
  2. tokamax._src.ops.fuser_adapter ตั้งค่าแฟล็กบริบทผู้ใช้ JAX (in_op_fusion_context()) รอบๆ jax.experimental.pallas.fuser.fuse
  3. เมื่อ Op.__call__ ทำงานภายในบริบทนั้น ระบบจะตรวจสอบว่าคลาสย่อยลบล้าง _fusible_fwd หรือไม่ (เพิ่ม NotImplementedError หากไม่) และมอบสิทธิ์ให้ fuser_adapter.call_fusible_op
  4. call_fusible_op ระงับบริบทการรวมขณะแก้ไข bound_args.default_config, ผูก fuser.fusible พื้นฐานไว้เหนือใบอาร์เรย์, แสดงอาร์กิวเมนต์ที่ไม่ได้ระบุไว้ใน Op.fusible_argnames และเรียกใช้ Op._fusible_fwd(*args, out_fusions=out_fusions, config=config, **kwargs) ภายใน bound_args._tokamax_metadata(config)

ขั้นตอนที่ 1: ประกาศ fusible_argnames และลบล้าง _fusible_fwd ใน Op

ในคลาสย่อย Op ของแบ็กเอนด์ (ดูข้อมูลอ้างอิงทั้งหมดได้ที่ PallasMosaicTpuV2RaggedDot) ให้ทำดังนี้

  1. ตั้งค่า fusible_argnames เป็นชื่อพารามิเตอร์ที่ใบอาร์เรย์ควรยังคงเป็น Closure ของ fuser.Fusion อาร์กิวเมนต์อาร์เรย์อื่นๆ ทั้งหมด (เช่น ข้อมูลเมตา ดัชนี หรือ group_sizes) จะได้รับการแปลงเป็น jax.Array ปกติโดยอัตโนมัติด้วย call_fusible_op ก่อนที่ _fusible_fwd จะทำงาน
  2. ลบล้าง _fusible_fwd _fusible_fwd จะแสดงผลลัพธ์ T โดยตรงและรับ out_fusions และ config ที่แก้ไขแล้ว ซึ่งต่างจาก _fwd (ซึ่งแสดงผล (out, residuals))
  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
    )

ขั้นตอนที่ 2: เก็บการผสานรวม Fuser ไว้ในโมดูล *_fuser.py ของ Companion

ทำตามการแยกของ Tokamax ระหว่างเคอร์เนลหลัก (gmm_v2.py, tgmm_v2.py) และการผสานรวม Fuser (gmm_fuser.py) ดังนี้

  • เก็บการนำเข้า jax.experimental.pallas.fuser ไว้นอกไฟล์เคอร์เนลหลักเพื่อให้เคอร์เนลที่ไม่ได้รวมยังคงเป็นแบบสมบูรณ์ในตัวและอ่านง่าย
  • Unwrap 0-equation trivial fuser.Fusion closures before building your fusion spec:

    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 จะรวม Leaf ของอาร์เรย์อินพุตทุกรายการไว้ใน Fusion แม้ว่าตัวถูกดำเนินการนั้นจะไม่มีการดำเนินการของผู้ผลิตก็ตาม การแยก Wrapper ของการปิดเล็กน้อยจะเก็บตัวถูกดำเนินการที่ไม่มีการแตะต้องไว้ในเส้นทาง BlockSpec ที่ไม่มีการหลอมรวมและไม่มีการแก้ไข โดยไม่มีค่าใช้จ่ายเพิ่มเติมในรันไทม์

  • หากเคอร์เนลพื้นฐานของคุณมีการตกแต่งด้วย @jax.jit ให้เรียกใช้ inspect.unwrap(base_kernel) บนเส้นทางที่หลอมรวมได้ เนื่องจาก @jax.jit จะปฏิเสธ fuser.Fusion อาร์กิวเมนต์

  • หากผู้เรียกใช้ Bare-Kernel ควรเรียกใช้จุดแรกเข้าที่รวมได้โดยตรงภายใน @fuser.fuse ได้ด้วย ให้ตรวจหาการเรียกใช้ jax.Array แบบ Bare และเชื่อมโยง fuser.fusible โดยอัตโนมัติ (เช่นเดียวกับที่ gmm_fuser.gmm_v2_fusible ทำ)

ขั้นตอนที่ 3: แกะกล่องฟิวชันและเปลี่ยนโฉม BlockSpec ด้วย fuser_adapter

ใช้ตัวช่วยที่ใช้ร่วมกันใน tokamax._src.ops.fuser_adapter แทนการเรียกใช้ API fuser ระดับต่ำโดยตรง

  • แยกส่วนบทนำของอินพุต

    lhs_fn, lhs_values, lhs_values_type = fuser_adapter.unpack_input_fusion(lhs)
    

    แสดงผล (fn, values, values_type) โดยที่ values คือ Tuple ของอาร์เรย์ HBM ที่ปิดโดย Prologue และ values_type เก็บ ShapeDtypeStruct ไว้

  • แยก Epilogue ที่มีเอาต์พุตเดียว:

    out_fn, out_values, out_values_type, out_init = (
        fuser_adapter.unpack_output_fusion(out_fusions, raw_out_type)
    )
    

    แกะรูปแบบเอาต์พุต 1-tuple ของ Pallas Fuser ออกเป็น 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-tuple และรักษาความเข้ากันได้ในรุ่น JAX ที่รองรับ

ขั้นตอนที่ 4: เชื่อมต่อข้อกำหนดและ Callback ที่ดึงมาเข้ากับ Pallas Kernel

  1. ส่งอินพุต HBM ที่บันทึกไว้พร้อมกับ BlockSpec ที่ดึงมา
    • อินพุต Prologue values แทนที่ตัวถูกดำเนินการที่รวมกัน (จับคู่กับ lhs_val_specs)
    • อินพุตด้านข้างของ Epilogue เอาต์พุต (out_values เช่น Epilogue Bias หรือ Residual) จะส่งเป็นอินพุตเคอร์เนล HBM แบบอ่านอย่างเดียวที่จับคู่กับ out_fusion_input_specs เพื่อให้ pltpu.emit_pipeline ดึงข้อมูลไทล์ล่วงหน้าลงใน VMEM เมื่อไม่ได้รวม ให้ส่ง Tuple () ที่ว่างเปล่าสำหรับทั้ง refs และ specs (0 PyTree leaves)
  2. ใช้ประเภท PyTree ที่แตกต่างกันต่อโหมดการรวม:
    • pltpu.emit_pipeline แมป jax.tree.map(..., in_specs, in_refs) ดังนั้นคอนเทนเนอร์อ้างอิงอินพุตแต่ละรายการและคอนเทนเนอร์ in_spec ของคอนเทนเนอร์นั้นต้องใช้ประเภท PyTree @jax.tree_util.register_dataclass เดียวกันทุกประการ (เช่น LhsRef[T] สำหรับ lhs ที่ไม่ได้รวมกัน เทียบกับ FusedLhsRef[T] สำหรับ lhs ที่รวมกันในบทนำ)
  3. ประเมิน Callback ที่ดึงมาในไทล์ VMEM ภายในเนื้อหาเคอร์เนล:

    • ฟังก์ชันที่ดึงมาทุกฟังก์ชันมีลายเซ็น 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 หากเคอร์เนลที่ไม่ได้รวมเปลี่ยนรูปแบบอินพุต HBM แบบ 2 มิติเป็นข้อมูลอ้างอิงแบบ Sublane-tiled แบบ 3 มิติก่อน emit_pipeline ให้แปลงข้อกำหนดเป็น BlockSpec((pl.BoundedSlice(tile_m), col_dim), ...) แบบ 2 มิติก่อนดึงหรือพุชผ่านตัวถูกดำเนินการที่รวม (ดู _to_2d_bounded_spec ใน gmm_fuser.py)
  • การจัดลำดับ Epilogue ด้วยการมาสก์แถว: หากเคอร์เนลมาสก์แถวนอกกลุ่มหรือแถวระยะห่างจากขอบเป็น 0 และรวมไทล์เลนย่อยบางส่วนในขั้นตอนต่างๆ ให้เรียกใช้ out_fn ก่อนใช้มาสก์ 0 เพื่อไม่ให้ Epilogue ที่ไม่ใช่ 0 (เช่น + bias) ทำให้แถวที่มาสก์เสียหาย
  • pl.kernel ที่มี 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() ของข้อกำหนดการรวม และเพิ่ม NotImplementedError สำหรับรูปร่างที่ไม่รองรับแทนการเสริมออบเจ็กต์ Fusion
  • Opตัวช่วยภายใน _fusible_fwd: call_fusible_op จะระงับ in_op_fusion_context() ระหว่างการแก้ไข default_config และภายใน _fusible_fwd ดังนั้นการเรียกใช้Opตัวช่วยที่ไม่ได้หลอมรวมภายใน _fusible_fwd จะเรียกใช้เส้นทาง _fwd ปกติโดยไม่ทำให้เกิดข้อผิดพลาดในการหลอมรวมที่ซ้อนกัน

เช็กลิสต์การทดสอบ

เมื่อเพิ่มการรองรับฟิวชันให้กับโอเปอเรเตอร์ ให้ครอบคลุมสิ่งต่อไปนี้

  1. Prologue fusion (การลด Pointwise และ Full-axis เช่น RMSNorm), Epilogue fusion (มีและไม่มีอินพุตด้านข้างภายนอก เช่น Bias หรือ Residual) และ Prologue + Epilogue แบบรวม
  2. ความเท่าเทียมแบบไม่มีการรวม: ตรวจสอบว่าการเรียกจุดแรกเข้าที่รวมได้โดยไม่มีการดำเนินการโดยรอบ (ธรรมดา, @op_fusion.fuse และ @fuser.fuse) จะสร้างเอาต์พุตที่เหมือนกันระดับบิต (chex.assert_trees_all_equal) กับเคอร์เนลที่ไม่ได้รวม
  3. @jax.custom_vjp Gradients ที่ชัดเจน: ตรวจสอบว่าค่าส่งต่อและ Gradients ตรงกับการอ้างอิงที่ไม่ได้รวมเข้าด้วยกัน
  4. ชุดค่าผสมที่ไม่รองรับ: ตรวจสอบข้อความ NotImplementedError ที่ชัดเจนสำหรับรูปร่างที่ไม่สอดคล้องกันหรือตัวเลือกเคอร์เนลที่เข้ากันไม่ได้

การใช้งานอ้างอิง