liger-kernel-nightly 0.6.1.dev20250730201330__tar.gz → 0.6.1.dev20250730201750__tar.gz

{liger_kernel_nightly-0.6.1.dev20250730201330 → liger_kernel_nightly-0.6.1.dev20250730201750}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: liger_kernel_nightly
-Version: 0.6.1.dev20250730201330
+Version: 0.6.1.dev20250730201750
 Summary: Efficient Triton kernels for LLM Training
 License: BSD 2-CLAUSE LICENSE
         Copyright 2024 LinkedIn Corporation 

{liger_kernel_nightly-0.6.1.dev20250730201330 → liger_kernel_nightly-0.6.1.dev20250730201750}/benchmark/scripts/benchmark_fused_linear_cross_entropy.py

@@ -34,10 +34,12 @@ class TorchLMHeadCE(torch.nn.Module):
 
 
 class LigerLMHeadCE(torch.nn.Module):
-    def __init__(self, H: int, V: int, dtype: torch.dtype, ignore_index: int = -100):
+    def __init__(self, H: int, V: int, dtype: torch.dtype, ignore_index: int = -100, accum_dtype=None):
         super().__init__()
         self.lin = torch.nn.Linear(in_features=H, out_features=V, bias=False, dtype=dtype)
-        self.ce_loss = LigerFusedLinearCrossEntropyLoss(ignore_index=ignore_index, reduction="mean")
+        self.ce_loss = LigerFusedLinearCrossEntropyLoss(
+            ignore_index=ignore_index, reduction="mean", accum_dtype=accum_dtype
+        )
 
     def forward(self, x, y):
         return self.ce_loss(self.lin.weight, x, y)
@@ -59,6 +61,7 @@ def bench_memory_fused_linear_cross_entropy(
 
     torch_lm_head_ce = TorchLMHeadCE(H=H, V=V, dtype=dtype).to(device)
     liger_lm_head_ce = LigerLMHeadCE(H=H, V=V, dtype=dtype).to(device)
+    liger_lm_head_ce_fp32_accum = LigerLMHeadCE(H=H, V=V, dtype=dtype, accum_dtype=torch.float32).to(device)
 
     _input = torch.randn(BT, H, requires_grad=True, dtype=dtype, device=device)
     target = torch.randint(V, (BT, 1), dtype=torch.long, device=device).squeeze(1)
@@ -66,6 +69,8 @@ def bench_memory_fused_linear_cross_entropy(
     def fwd():
         if provider == "liger":
             return liger_lm_head_ce(_input, target)
+        elif provider == "liger-fp32-accum":
+            return liger_lm_head_ce_fp32_accum(_input, target)
         elif provider == "huggingface":
             return torch_lm_head_ce(_input, target)
 
@@ -98,6 +103,7 @@ def bench_speed_fused_linear_cross_entropy(
 
     torch_lm_head_ce = TorchLMHeadCE(H=H, V=V, dtype=dtype).to(device)
     liger_lm_head_ce = LigerLMHeadCE(H=H, V=V, dtype=dtype).to(device)
+    liger_lm_head_ce_fp32_accum = LigerLMHeadCE(H=H, V=V, dtype=dtype, accum_dtype=torch.float32).to(device)
 
     _input = torch.randn(BT, H, requires_grad=True, dtype=dtype, device=device)
     target = torch.randint(V, (BT, 1), dtype=torch.long, device=device).squeeze(1)
@@ -105,6 +111,8 @@ def bench_speed_fused_linear_cross_entropy(
     def fwd():
         if provider == "liger":
             return liger_lm_head_ce(_input, target)
+        elif provider == "liger-fp32-accum":
+            return liger_lm_head_ce_fp32_accum(_input, target)
         elif provider == "huggingface":
             return torch_lm_head_ce(_input, target)
 
@@ -149,7 +157,7 @@ if __name__ == "__main__":
         "x_name": "BT",
         "x_label": "B x T",
         "x_values": [2**i for i in range(12, 16)],
-        "kernel_providers": ["liger", "huggingface"],
+        "kernel_providers": ["liger", "liger-fp32-accum", "huggingface"],
         "extra_benchmark_configs": [{"H": 4096, "V": 128256, "mode": "forward", "dtype": torch.bfloat16}],
         "overwrite": args.overwrite,
     }

{liger_kernel_nightly-0.6.1.dev20250730201330 → liger_kernel_nightly-0.6.1.dev20250730201750}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "liger_kernel_nightly"
-version = "0.6.1.dev20250730201330"
+version = "0.6.1.dev20250730201750"
 description = "Efficient Triton kernels for LLM Training"
 urls = { "Homepage" = "https://github.com/linkedin/Liger-Kernel" }
 readme = { file = "README.md", content-type = "text/markdown" }

{liger_kernel_nightly-0.6.1.dev20250730201330 → liger_kernel_nightly-0.6.1.dev20250730201750}/src/liger_kernel/ops/fused_linear_cross_entropy.py

@@ -25,6 +25,7 @@ def fused_linear_cross_entropy_forward(
     reduction="mean",
     softcap=None,
     return_z_loss=False,
+    accum_dtype=None,
 ):
     assert isinstance(return_z_loss, bool), f"return_z_loss must be True or False. Got: {return_z_loss}"
     device = _input.device
@@ -44,10 +45,16 @@ def fused_linear_cross_entropy_forward(
     chunk_size = triton.next_power_of_2(triton.cdiv(BT, inc_factor))  # (BT + inc_factor - 1) // inc_factor
     num_chunks = triton.cdiv(BT, chunk_size)  # (BT + chunk_size - 1) // chunk_size
 
-    grad_weight = torch.zeros_like(weight, device=device) if weight.requires_grad else None
     grad_input = torch.zeros_like(_input, device=device)
-    grad_bias = torch.zeros_like(bias, device=device) if bias is not None else None
-    # we use fp32 for loss accumulator
+
+    # we use fp32 for loss and gradients accumulator
+    if accum_dtype is None:
+        grad_weight = torch.zeros_like(weight, device=device) if weight.requires_grad else None
+        grad_bias = torch.zeros_like(bias, device=device) if bias is not None else None
+    else:
+        grad_weight = torch.zeros_like(weight, dtype=accum_dtype, device=device) if weight.requires_grad else None
+        grad_bias = torch.zeros_like(bias, dtype=accum_dtype, device=device) if bias is not None else None
+
     loss_1d = torch.zeros(BT, dtype=torch.float32, device=device)
     z_loss_1d = torch.zeros(BT, dtype=_input.dtype, device=_input.device) if return_z_loss else None
 
@@ -124,16 +131,7 @@ def fused_linear_cross_entropy_forward(
         grad_input[start_idx:end_idx] = grad_logits_chunk @ weight
 
         if grad_weight is not None:
-            torch.addmm(
-                input=grad_weight,
-                mat1=logits_chunk.t().to(
-                    _input_chunk.dtype
-                ),  # In an autocast scenario without bias, differing logits_chunk data types will cause an addmm operation error.
-                mat2=_input_chunk,
-                out=grad_weight,
-                alpha=1.0,
-                beta=1.0,
-            )
+            grad_weight += torch.mm(grad_logits_chunk.t(), _input_chunk).float()
 
         if bias is not None:
             torch.add(
@@ -151,6 +149,11 @@ def fused_linear_cross_entropy_forward(
     else:
         loss = torch.sum(loss_1d)
         z_loss = torch.sum(z_loss_1d) if return_z_loss else None
+
+    # Cast back to original dtype
+    grad_weight = grad_weight.to(weight.dtype) if grad_weight is not None else None
+    grad_bias = grad_bias.to(bias.dtype) if grad_bias is not None else None
+
     return loss, z_loss, grad_input, grad_weight, grad_bias
 
 
@@ -217,6 +220,7 @@ class LigerFusedLinearCrossEntropyFunction(torch.autograd.Function):
         reduction="mean",
         softcap=None,
         return_z_loss: bool = False,
+        accum_dtype=None,
     ):
         """
         Fusing the last linear layer with cross-entropy loss
@@ -235,6 +239,8 @@ class LigerFusedLinearCrossEntropyFunction(torch.autograd.Function):
         ignore_index: the index to ignore in the target
         label_smoothing (float): The amount of smoothing when computing the loss, where 0.0 means no smoothing.
         reduction: reduction to apply
+        accum_dtype (torch.dtype): the dtype of intermediate result buffers for weight and bias gradient accumulations.
+            Recommended to set `accum_dtype` to higher precision, e.g. `torch.float32`, if the training is unstable with original dtype. Default: `None`, performing accumulations in original dtype
         """
 
         loss, z_loss, grad_input, grad_weight, grad_bias = fused_linear_cross_entropy_forward(
@@ -249,6 +255,7 @@ class LigerFusedLinearCrossEntropyFunction(torch.autograd.Function):
             reduction=reduction,
             softcap=softcap,
             return_z_loss=return_z_loss,
+            accum_dtype=accum_dtype,
         )
         # downcast to dtype and store for backward
         ctx.save_for_backward(
@@ -280,4 +287,5 @@ class LigerFusedLinearCrossEntropyFunction(torch.autograd.Function):
             None,
             None,
             None,
+            None,
         )

{liger_kernel_nightly-0.6.1.dev20250730201330 → liger_kernel_nightly-0.6.1.dev20250730201750}/src/liger_kernel/transformers/functional.py

@@ -64,6 +64,7 @@ def liger_fused_linear_cross_entropy(
     reduction: str = "mean",
     softcap: Optional[float] = None,
     return_z_loss: bool = False,
+    accum_dtype=None,
 ):
     loss, z_loss = LigerFusedLinearCrossEntropyFunction.apply(
         input,
@@ -77,6 +78,7 @@ def liger_fused_linear_cross_entropy(
         reduction,
         softcap,
         return_z_loss,
+        accum_dtype,
     )
     if not return_z_loss:
         return loss

{liger_kernel_nightly-0.6.1.dev20250730201330 → liger_kernel_nightly-0.6.1.dev20250730201750}/src/liger_kernel/transformers/fused_linear_cross_entropy.py

@@ -15,6 +15,7 @@ class LigerFusedLinearCrossEntropyLoss(torch.nn.Module):
         reduction: str = "mean",
         softcap: Optional[float] = None,
         return_z_loss: bool = False,
+        accum_dtype: Optional[torch.dtype] = None,
     ):
         super().__init__()
         assert (label_smoothing >= 0) and (label_smoothing <= 1), (
@@ -32,6 +33,7 @@ class LigerFusedLinearCrossEntropyLoss(torch.nn.Module):
         self.reduction = reduction
         self.softcap = softcap
         self.return_z_loss = return_z_loss
+        self.accum_dtype = accum_dtype
 
     def forward(self, lin_weight, _input, target, bias=None):
         loss, z_loss = LigerFusedLinearCrossEntropyFunction.apply(
@@ -46,6 +48,7 @@ class LigerFusedLinearCrossEntropyLoss(torch.nn.Module):
             self.reduction,
             self.softcap,
             self.return_z_loss,
+            self.accum_dtype,
         )
         if not self.return_z_loss:
             return loss

{liger_kernel_nightly-0.6.1.dev20250730201330 → liger_kernel_nightly-0.6.1.dev20250730201750}/src/liger_kernel_nightly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: liger_kernel_nightly
-Version: 0.6.1.dev20250730201330
+Version: 0.6.1.dev20250730201750
 Summary: Efficient Triton kernels for LLM Training
 License: BSD 2-CLAUSE LICENSE
         Copyright 2024 LinkedIn Corporation 

{liger_kernel_nightly-0.6.1.dev20250730201330 → liger_kernel_nightly-0.6.1.dev20250730201750}/test/transformers/test_fused_linear_cross_entropy.py

@@ -80,6 +80,7 @@ class LigerLMHeadCE(torch.nn.Module):
         reduction: str = "mean",
         softcap: Optional[float] = None,
         return_z_loss: bool = False,
+        accum_dtype=None,
     ):
         super().__init__()
         self.lin = torch.nn.Linear(in_features=H, out_features=V, bias=bias, dtype=dtype)
@@ -91,6 +92,7 @@ class LigerLMHeadCE(torch.nn.Module):
             reduction=reduction,
             softcap=softcap,
             return_z_loss=return_z_loss,
+            accum_dtype=accum_dtype,
         )
 
     def forward(self, x, y):
@@ -120,11 +122,11 @@ class LigerLMHeadCE(torch.nn.Module):
 )
 @pytest.mark.parametrize("bias", [True, False])
 @pytest.mark.parametrize(
-    "has_ce_weight, label_smoothing, ignore_index, lse_square_scale, softcap, return_z_loss",
+    "has_ce_weight, label_smoothing, ignore_index, lse_square_scale, softcap, return_z_loss, accum_dtype",
     [
-        (False, 0, -100, 0, None, False),
+        (False, 0, -100, 0, None, False, None),
         # Pass non-default values once to ensure all params work along
-        (True, 0.1, 42, 1e-4, 30.0, True),
+        (True, 0.1, 42, 1e-4, 30.0, True, torch.float32),
     ],
 )
 def test_correctness(
@@ -142,6 +144,7 @@ def test_correctness(
     reduction,
     softcap,
     return_z_loss,
+    accum_dtype,
     atol,
     rtol,
 ):
@@ -174,6 +177,7 @@ def test_correctness(
         softcap=softcap,
         return_z_loss=return_z_loss,
         dtype=dtype,
+        accum_dtype=accum_dtype,
     ).to(device)
 
     # init the linear in all CEs with the same weights
@@ -267,9 +271,10 @@ def test_correctness_functional(B, T, H, V, scalar, dtype, bias, ce_weight, atol
         reduction="mean",
         softcap=30.0,
         return_z_loss=True,
+        accum_dtype=torch.float32,
     )
     y2, z2 = LigerFusedLinearCrossEntropyFunction.apply(
-        x2, weight, target, bias, ce_weight, -100, 1e-4, 0.1, "mean", 30.0, True
+        x2, weight, target, bias, ce_weight, -100, 1e-4, 0.1, "mean", 30.0, True, torch.float32
     )
 
     assert torch.allclose(y1, y2, atol=atol, rtol=rtol)
@@ -299,7 +304,8 @@ def test_correctness_functional(B, T, H, V, scalar, dtype, bias, ce_weight, atol
         (False, torch.float16, 5e-3, 5e-2),
     ],
 )
-def test_amp(B, T, H, V, bias, cast_dtype, atol, rtol):
+@pytest.mark.parametrize("accum_dtype", [None, torch.float32])
+def test_amp(B, T, H, V, bias, cast_dtype, accum_dtype, atol, rtol):
     dtype = torch.float32
     torch_lm_head_ce = TorchLMHeadCE(
         H=H,
@@ -316,6 +322,7 @@ def test_amp(B, T, H, V, bias, cast_dtype, atol, rtol):
         label_smoothing=0.0,
         reduction="mean",
         dtype=dtype,
+        accum_dtype=accum_dtype,
     ).to(device)
 
     # init the linear in all CEs with the same weights