Kernels:

kernels-community
/

fla

Trusted publisher

kernels-bot commited on 7 days ago

Commit

482971d

verified ·

1 Parent(s): a8f840e

Uploaded using `kernel-builder`.

Browse files

Files changed (4) hide show

build/torch-xpu/_ops.py +3 -6
build/torch-xpu/metadata.json +6 -5
build/torch-xpu/metadata.json.sigstore +1 -1
build/torch-xpu/symbols.json +640 -0

build/torch-xpu/_ops.py CHANGED Viewed

@@ -4,11 +4,8 @@ def get_backend() -> str:
     """Detect the backend by inspecting torch."""
     import torch
-    if hasattr(torch.backends, "tpu"):
-        # torch_tpu sets torch.backends.tpu when it is imported (via
-        # torch's device-backend autoload), regardless of whether TPU
-        # hardware is present — analogous to torch.version.cuda being
-        # set on CUDA builds without a GPU.
         return "tpu"
     elif hasattr(torch, "neuron"):
         # Needs to be sorted before specific Torch builds, since Neuron
@@ -28,7 +25,7 @@ def get_backend() -> str:
 def _find_ops_name() -> str:
     kernel_name = "fla"
-    unique_id = "4123f96"
     backend = get_backend()
     return f"_{kernel_name}_{backend}_{unique_id}"

     """Detect the backend by inspecting torch."""
     import torch
+    acc = torch.accelerator.current_accelerator() if hasattr(torch, "accelerator") else None
+    if acc is not None and acc.type == "tpu":
         return "tpu"
     elif hasattr(torch, "neuron"):
         # Needs to be sorted before specific Torch builds, since Neuron
 def _find_ops_name() -> str:
     kernel_name = "fla"
+    unique_id = "fe2bb66"
     backend = get_backend()
     return f"_{kernel_name}_{backend}_{unique_id}"

build/torch-xpu/metadata.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "fla",
-  "id": "_fla_xpu_4123f96",
   "version": 1,
   "kernels-minver": "0.14.0",
   "license": "MIT",
@@ -15,7 +15,7 @@
     "algorithm": "sha256",
     "files": {
       "__init__.py": "bVRNYUhThvULeUaovvQFZCJ9IZZsC+0kU/HbnXdYT1A=",
-      "_ops.py": "rPd2DbBpAEbo/sPo6j0J3FyPZaEve1snpaon088YxYY=",
       "layers.py": "/39XVQW4d4GHeNROqT67ujKbItdteLBtm0PT6zq41YQ=",
       "modules/__init__.py": "6ZjjRMt6Rf+2OegXDC8w58RD1IW3SBK+dxBoZa4Uohc=",
       "modules/activations.py": "Lp7xLUf7r785nt93NFhqoSQM+G7AK2e6kviE2/0TRJs=",
@@ -296,6 +296,7 @@
       "ops/wall_attn/decode.py": "JphI1kWj0Wwu024gnwgUWrWmhkAnKloXi1ik6cDpRrY=",
       "ops/wall_attn/naive.py": "9YKwBSvQ9imy229T5KMYKpuVNb+xEzhXsXdMemRWqjQ=",
       "ops/wall_attn/parallel.py": "oa2UJtSi8ouSG8g6bUWHwOehbwLH74SSHIU8LUiwVrg=",
       "utils/__init__.py": "bdtrr5b2e7dzcO88Il6bH72LypiM103tHkbY2kPoaeE=",
       "utils/_compat.py": "kYAtqK4JdTczM1FpqT44T/mILN7DcnPb8C4uPnO4Ho0=",
       "utils/_config.py": "l1PBnf2C6SABltOAhs9GB0GTr0olQ1fA7d/bhzTb6IA=",
@@ -308,12 +309,12 @@
   },
   "provenance": {
     "kernel-builder": {
-      "version": "0.17.0-dev0",
-      "commit": "a7f0afdb29a6a3372b1d47180cc0c182454c5e3b",
       "dirty": false
     },
     "kernel": {
-      "commit": "4123f96f64775eda6e94f87cdf8483e923b86d20",
       "dirty": false
     }
   }

 {
   "name": "fla",
+  "id": "_fla_xpu_fe2bb66",
   "version": 1,
   "kernels-minver": "0.14.0",
   "license": "MIT",
     "algorithm": "sha256",
     "files": {
       "__init__.py": "bVRNYUhThvULeUaovvQFZCJ9IZZsC+0kU/HbnXdYT1A=",
+      "_ops.py": "pXgvH5hf/dXVr6/amV+mRqgiBUGncbV3gbMubhmlOW4=",
       "layers.py": "/39XVQW4d4GHeNROqT67ujKbItdteLBtm0PT6zq41YQ=",
       "modules/__init__.py": "6ZjjRMt6Rf+2OegXDC8w58RD1IW3SBK+dxBoZa4Uohc=",
       "modules/activations.py": "Lp7xLUf7r785nt93NFhqoSQM+G7AK2e6kviE2/0TRJs=",
       "ops/wall_attn/decode.py": "JphI1kWj0Wwu024gnwgUWrWmhkAnKloXi1ik6cDpRrY=",
       "ops/wall_attn/naive.py": "9YKwBSvQ9imy229T5KMYKpuVNb+xEzhXsXdMemRWqjQ=",
       "ops/wall_attn/parallel.py": "oa2UJtSi8ouSG8g6bUWHwOehbwLH74SSHIU8LUiwVrg=",
+      "symbols.json": "mLYlaOKZomfTLhl4BVcyn4O5q2XY2OfxWDiw6nZrSrU=",
       "utils/__init__.py": "bdtrr5b2e7dzcO88Il6bH72LypiM103tHkbY2kPoaeE=",
       "utils/_compat.py": "kYAtqK4JdTczM1FpqT44T/mILN7DcnPb8C4uPnO4Ho0=",
       "utils/_config.py": "l1PBnf2C6SABltOAhs9GB0GTr0olQ1fA7d/bhzTb6IA=",
   },
   "provenance": {
     "kernel-builder": {
+      "version": "0.18.0-dev0",
+      "commit": "d054906a13710b811b96697b4635f03020842733",
       "dirty": false
     },
     "kernel": {
+      "commit": "fe2bb66fee6c2a77eccf08a0508dc57428d488ed",
       "dirty": false
     }
   }

build/torch-xpu/metadata.json.sigstore CHANGED Viewed

@@ -1 +1 @@

- {"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json", "verificationMaterial":{"certificate":{"rawBytes":"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"}, "tlogEntries":[{"logIndex":"2793362354", "logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="}, "kindVersion":{"kind":"hashedrekord", "version":"0.0.1"}, "integratedTime":"1789130768", "inclusionPromise":{"signedEntryTimestamp":"MEQCIGKV83P0BgFHqobBk72noNoAEddF5i0mL6+7aboimkzlAiAhrg6FJ7CW4BH+uAR0eBsc7W7aTr4iF+FOp3+Focr17Q=="}, "inclusionProof":{"logIndex":"2671458092", "rootHash":"ANa4CJ8rYhknUcf5LwE7mS5c+92lA6aLHO/Z2NtTY+A=", "treeSize":"2671458115", "hashes":["slEQblbMYqePBCt7cry09itMV2MtecsQlxoFWRAOvx8=", "9syqG8w8oiXhxh5KXqsckrGwgyND9HT42ji+u9olmu0=", "kxHac7K3kx7wFjO4G1ptbhm+5sk6jW9aai1bBYdn2nM=", "B/V6sXsuiatY1gSG6i/5ugHv/7fzK35ZDegs79vsSOI=", "0zN1Tz3TiG/gBH5ULTVm1pzhHHIL3caE5brBzRbKQEY=", "Za5HK3xABuajEYZP+THCeYjJ3Dh0Moqx1UpYwq9cSME=", "j4kslJqSj/pADtr8lSiZnGG54Sg6PYCPUQ/00qlyWJk=", "boSBwC21uMQAMndX7Z8d4D8K+MYXVfFPy9DoeueE6ug=", "sPl07GzZyajNTQKGw59Xf5i3P/yDTlwAxXO4kN6FP7s=", "z54K+8JsNrvBQ2+Mhdsl0CUVzOMFf5twZgR/dj6RkAA=", "QSceGXuGTW/9/g+10B4y4zChaUpvaKLUZaLscFeOkAw=", "tsHhfJ+X4RzI9PA4JV0E91uOIJxXQRN7iEOZuxOIvKo=", "HjIF5qmuq64UWjnlLDUL73mqoLvbcmcWoxZTIccCZiY=", "k+BNotUfxhhXkBmIxNKyQj+1wiL82kdwx2Gq2N4D4Jc=", "AQMAZinvrdBp0wx7QCP1xhhBIIuI3ZKYBvZzHDq2NIw=", "tmmncJvF9VDF4uh5faBrieoKJbtWN2rpKvk3uQQ2W8o=", "/mjQogAQefxrs6hDWFie0uOlNqZc4omr6I+XxshnZ1Y=", "Ari+W6zWoRpeR1Lw5lnM64DXE7cw7awR/QTfo7IO3PM=", "4SexKjDhe33uQFmbzX5SUsB0SyhTm14ObSvNGPpKDFk=", "7tD2K8mAqGTMENrP2YXWz71BeTWQPCiYd3CESAgQLz8=", "eXSLrLqKSxRTixSP/k4YimriB2lufao6trqTrsxxlyg=", "SndbMKVtcTenAkwi2JBfGzD+mhexp1qJbRIY+A1JRIU=", "xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="], "checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n2671458115\nANa4CJ8rYhknUcf5LwE7mS5c+92lA6aLHO/Z2NtTY+A=\n\n— rekor.sigstore.dev wNI9ajBGAiEA1bASs1lRPR3nHKa9VmWd5pPJPRFqMWzEZs2IHMcsr/sCIQCPIEehohgEFTU1Bp5KjVCBCpAreIhpC3veRh5tsL4xVQ==\n"}}, "canonicalizedBody":"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"}], "timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyjADAgEAMIICwQYJKoZIhvcNAQcCoIICsjCCAq4CAQMxDTALBglghkgBZQMEAgEwgbgGCyqGSIb3DQEJEAEEoIGoBIGlMIGiAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgPslqQ2lbmYVVNfnAWTi5Fblkwx47eA3DyMErk+wbMv0CFQDy7EgZ1FsBmDmix+qzTd1MMb4RwBgPMjAyNjA5MTExMjQ2MDhaMAMCAQGgMqQwMC4xFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEVMBMGA1UEAxMMc2lnc3RvcmUtdHNhoAAxggHbMIIB1wIBATBRMDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAsGCWCGSAFlAwQCAaCB/DAaBgkqhkiG9w0BCQMxDQYLKoZIhvcNAQkQAQQwHAYJKoZIhvcNAQkFMQ8XDTI2MDkxMTEyNDYwOFowLwYJKoZIhvcNAQkEMSIEIO1x7kjXoXusYUVglJzpMxPrrJK7IJ8cqyQr2qpM0Sg3MIGOBgsqhkiG9w0BCRACLzF/MH0wezB5BCCF+Se8B6tiysO0Q1bBDvyBssaIP9p6uebYcNnROs0FtzBVMD2kOzA5MRUwEwYDVQQKEwxzaWdzdG9yZS5kZXYxIDAeBgNVBAMTF3NpZ3N0b3JlLXRzYS1zZWxmc2lnbmVkAhQ6E1QvDJBh7rzBQy/Lio6LKiOLDDAKBggqhkjOPQQDAgRnMGUCMQDiq8h6Uq+z3gvPFyVPHxju1tMYwolHd6DaKMMRZETk/ev5rhO+byQ+/Aw/n2FbZZwCMGXNlKj0Ur8xSXTfwnBGnUD7SkU3IqJHdcGWdqn7JVJvqjLqC3hqiN4ouiW1z6XvWA=="}]}}, "messageSignature":{"messageDigest":{"algorithm":"SHA2_256", "digest":"JzJVopizKPN2xDcv+czf0a8xRNEVj3NcRcXpH9PkQ4s="}, "signature":"MEUCIBuCYznp9S753Lh/s4SM/QK4P9sIonZJYcggBTrr7BTEAiEAxrstrRQW6e1J2bNhLWe2gh9oN5hNHgXP5jm/eyaINTE="}}

+ {"mediaType":"application/vnd.dev.sigstore.bundle.v0.3+json", "verificationMaterial":{"certificate":{"rawBytes":"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"}, "tlogEntries":[{"logIndex":"3320106863", "logId":{"keyId":"wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="}, "kindVersion":{"kind":"hashedrekord", "version":"0.0.1"}, "integratedTime":"1792407656", "inclusionPromise":{"signedEntryTimestamp":"MEUCIBIXVACpzZk3A5UdTHJGNzY1+BEe8izv6WytQRoNurdRAiEAwiN6I127S9wYrzzhAp1KlLnJg6t79oYM7xeX1ljOCX8="}, "inclusionProof":{"logIndex":"3198202601", "rootHash":"7NFr/lK6Bzd15e0zU7FG33+UqCjS81C8Wqgavc/42PY=", "treeSize":"3198202606", "hashes":["Jqmf6hBm2SlbxPt6bWzI3yTDaXWJ9wpwn4oFUPfSzC4=", "Hu84dUxAvrcEUjbpHGVTa0v3W9f4bcLgyxJ9arIsA4k=", "iwjbHz8DebR+crQAEZT8SrEV6EY2d6vr38RBJMuRdI8=", "aSMGqrar0XadNbUv88cEFHH4z041bKA8kIwNb0/4dvw=", "da3b5yFUv0WI9AHoAIzLrj+mneing+E7+sN84uV6dyU=", "AIg+9CDrUOfKYHkholj8Hb5rLzOEXDmzH8bvEzlWT5A=", "9XILTHMRbuTH5s7/ktpnEOF5r3lYOe799pW7DVDKXb0=", "A9FtVzn33g4x+CTV70Ba6UZyAYH9uzW+6x2dh0lNvgI=", "fc0pcvawZCdBMV+HYOr/hQ5DyDVH7XSj5bkI9of0GLM=", "FEgdG4+ki96DDLGD8Iuzoy3Ym45SfhKnrkhNx+u0ElY=", "OlLDeTiZ1vIMDel4vGDtbNVnrFnzDe1MFV5rBN5Ep4o=", "uCZQe757l2sS1c05Y7TzOwEm+X8MeGLIUCkEOmFVOz4=", "nyQV/+cWQUG5Hb2PKjQQNkQIJmz2qzAZKBQlkHGIknM=", "G+nk7mgE5h6dUmv2UY7NDJrY3WvrZY31raaO1AETt+o=", "qlTWNDzERnTBQVcHHXXVPjiUP0SsikGxfcxVlgqVFDo=", "gg9GNApNke3+zNhl4tsWtmIycCFrOMCB3lys6XuSQNQ=", "NlOclldmKPA1tMKIskqHAwuQDYHp31YwpK+OOMrMccc=", "qxzHanAzz57SDdmJe0B7bJK72NTIBbwEMGBBKvDOROw=", "xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="], "checkpoint":{"envelope":"rekor.sigstore.dev - 1193050959916656506\n3198202606\n7NFr/lK6Bzd15e0zU7FG33+UqCjS81C8Wqgavc/42PY=\n\n— rekor.sigstore.dev wNI9ajBFAiEAnIN6aO06lOxaFRKVVPyZZ+iY3yKFD7FjVuY2RcYj9SoCIBQUN/Yq8vPM0QLSjxPAH1I37N99dRXRjLZ48pJyi46Z\n"}}, "canonicalizedBody":"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"}], "timestampVerificationData":{"rfc3161Timestamps":[{"signedTimestamp":"MIICyDADAgEAMIICvwYJKoZIhvcNAQcCoIICsDCCAqwCAQMxDTALBglghkgBZQMEAgEwgbcGCyqGSIb3DQEJEAEEoIGnBIGkMIGhAgEBBgkrBgEEAYO/MAIwMTANBglghkgBZQMEAgEFAAQgSXEeWTKPy5M344/YFT/XP8azEPBYve+1t3rfl2y9fU8CFGZeBX8tHbhk1uWSO0u4AA1UktZhGA8yMDI2MTAxOTExMDA1NlowAwIBAaAypDAwLjEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MRUwEwYDVQQDEwxzaWdzdG9yZS10c2GgADGCAdowggHWAgEBMFEwOTEVMBMGA1UEChMMc2lnc3RvcmUuZGV2MSAwHgYDVQQDExdzaWdzdG9yZS10c2Etc2VsZnNpZ25lZAIUOhNULwyQYe68wUMvy4qOiyojiwwwCwYJYIZIAWUDBAIBoIH8MBoGCSqGSIb3DQEJAzENBgsqhkiG9w0BCRABBDAcBgkqhkiG9w0BCQUxDxcNMjYxMDE5MTEwMDU2WjAvBgkqhkiG9w0BCQQxIgQgwfvgGPFqgA9OvUgsLvMTGQENfojqD7cfseLFLfU9c84wgY4GCyqGSIb3DQEJEAIvMX8wfTB7MHkEIIX5J7wHq2LKw7RDVsEO/IGyxog/2nq55thw2dE6zQW3MFUwPaQ7MDkxFTATBgNVBAoTDHNpZ3N0b3JlLmRldjEgMB4GA1UEAxMXc2lnc3RvcmUtdHNhLXNlbGZzaWduZWQCFDoTVC8MkGHuvMFDL8uKjosqI4sMMAoGCCqGSM49BAMCBGYwZAIwYWMvEXVuabGURhsFSF1Y6rl227JXpU/4jZkBHXYZbZbN5Aqs8ZZw2U+hsJmLxqjyAjA9CeY2AqRWdIrE4bTzCHn/eZH533Bce4owlrDB6F9jzhkrgN9DihO3z3YSPGhRhGM="}]}}, "messageSignature":{"messageDigest":{"algorithm":"SHA2_256", "digest":"vR4KddFovSsc+cd0BSWNIvubsoNE+1Dbt58ORDumzZ0="}, "signature":"MEYCIQDsPDB8OL1gvnzSyF6TzJ2YjAoXHRdr8gRvNiWvWnq6IAIhAKzdA2n29j+s2+bMwThPB00tIooA9gQs3EEZ6osuXy/Z"}}

build/torch-xpu/symbols.json ADDED Viewed

	@@ -0,0 +1,640 @@

+{
+  "schema_version": 1,
+  "module": "_fla_xpu_fe2bb66",
+  "functions": [
+    {
+      "name": "chunk_kda",
+      "qualname": "chunk_kda",
+      "module": "_fla_xpu_fe2bb66.ops.kda.chunk",
+      "kind": "function",
+      "doc": "Args:\n    q (torch.Tensor):\n        queries of shape ``[B, T, H, K]``.\n    k (torch.Tensor):\n        keys of shape ``[B, T, H, K]``.\n    v (torch.Tensor):\n        values of shape ``[B, T, HV, V]``.\n        GVA (Grouped Value Attention) is applied if ``HV > H``, where ``HV`` must be divisible by ``H``.\n    g (torch.Tensor):\n        (forget) gating tensor (in log space!) of shape ``[B, T, HV, K]``.\n        When ``use_gate_in_kernel=False`` (default), ``g`` should be the pre-computed decay value.\n        When ``use_gate_in_kernel=True``, ``g`` is the raw input before gate activation;\n        the kernel fuses ``-exp(A_log) * softplus(g + dt_bias)`` + chunk cumsum internally.\n    beta (torch.Tensor):\n        betas of shape ``[B, T, HV]``.\n    scale (Optional[float]):\n        Scale factor for the KDA attention scores.\n        If not provided, it will default to ``1 / sqrt(K)``. Default: ``None``.\n    initial_state (Optional[torch.Tensor]):\n        Initial state of shape ``[N, HV, K, V]`` for ``N`` input sequences.\n        For equal-length input sequences, ``N`` equals the batch size ``B``.\n        Default: ``None``.\n    output_final_state (Optional[bool]):\n        Whether to output the final state of shape ``[N, HV, K, V]``. Default: ``False``.\n    use_qk_l2norm_in_kernel (bool):\n        Whether to apply L2norm to the q,k tensor internally. Default: ``False``.\n    use_gate_in_kernel (bool):\n        Whether to compute the log-space KDA decay internally.\n        - If ``True``:\n          The passed ``g`` acts as the raw input for ``-exp(A_log) * softplus(g + dt_bias.view(HV, K))``.\n          Note that as part of the input arguments,\n          ``A_log`` (shape ``[HV]``) and the optional ``dt_bias`` (shape ``[HV * K]``) should be provided.\n        - If ``False``, ``g`` is expected to be the pre-computed decay value.\n        Default: ``False``.\n    use_beta_sigmoid_in_kernel (bool):\n        Whether to apply ``torch.sigmoid(beta)`` before launching the chunk kernel.\n        - If ``True``, the passed ``beta`` acts as the raw beta logits.\n        - If ``False``, ``beta`` is expected to already be in post-sigmoid space.\n        Default: ``False``.\n    allow_neg_eigval (bool):\n        Whether to allow negative eigenvalues by scaling ``beta`` to ``[0, 2)``.\n        Only takes effect together with ``use_beta_sigmoid_in_kernel=True``, in which case\n        the kernel computes ``2 * sigmoid(beta)`` instead of ``sigmoid(beta)``.\n        Default: ``False``.\n    safe_gate (bool):\n        Whether to clamp the gate to ``[lower_bound, 0)`` and enable M=16 TensorCore\n        acceleration for higher throughput. Requires ``lower_bound`` to be set.\n        Default: ``False``.\n    lower_bound (Optional[float]):\n        Lower bound for the forget gate (in log space). When set together with\n        ``safe_gate=True``, changes the gate activation from\n        ``-exp(A_log) * softplus(g + dt_bias)`` to\n        ``lower_bound * sigmoid(exp(A_log) * (g + dt_bias))``,\n        which naturally clamps the output to ``[lower_bound, 0)``.\n        Recommended value: ``-5`` (i.e., per-step decay ``exp(-5) ≈ 0.0067``).\n        Default: ``None``.\n    disable_recompute (bool):\n        Whether to disable gradient recomputation in the kernel. When ``True``, the kernel\n        will save all intermediate activations for backward pass, which is beneficial\n        for training small models at the cost of increased memory usage. Default: ``False``.\n    return_intermediate_states (bool):\n        If True, returns intermediate state ``h`` for inference scenarios (e.g., vLLM).\n        Must be used within ``torch.inference_mode()`` and will return a 3-tuple instead of 2-tuple.\n        This is not intended for training as it bypasses autograd. Default: ``False``.\n    state_v_first (Optional[bool]):\n        Store the recurrent state in V-first ``[V, K]`` layout instead of the default ``[K, V]``. Default: ``False``.\n    cu_seqlens (torch.LongTensor):\n        Cumulative sequence lengths of shape ``[N+1]`` used for variable-length training,\n        consistent with the FlashAttention API.\n    cu_seqlens_cpu (torch.LongTensor):\n        Cumulative sequence lengths of shape ``[N+1]`` used for variable-length training,\n        consistent with the FlashAttention API.\n    cp_context (Optional[FLACPContext]):\n        Context parallel context for distributed training across multiple devices.\n        When provided, ``initial_state`` and ``output_final_state`` are not supported,\n        and ``cu_seqlens`` will be overridden by the context. Default: ``None``.\n\nReturns:\n    - Normal mode (return_intermediate_states=False): A tuple (o, final_state)\n        o (torch.Tensor):\n            Outputs of shape ``[B, T, HV, V]``.\n        final_state (torch.Tensor):\n            Final state of shape ``[N, HV, K, V]`` if ``output_final_state=True`` else ``None``.\n    - Inference mode (return_intermediate_states=True): A tuple (o, final_state, h)\n        o (torch.Tensor):\n            Outputs of shape ``[B, T, HV, V]``.\n        final_state (torch.Tensor):\n            Final state of shape ``[N, HV, K, V]`` if ``output_final_state=True`` else ``None``.\n        h (torch.Tensor):\n            Intermediate states of shape ``[B, NT, HV, K, V]`` and dtype ``bfloat16``.\n            - For equal-length sequences: ``NT = ceil(T / chunk_size)``\n            - For variable-length sequences (cu_seqlens): B is always 1 (flattened),\n              NT is the total number of chunks across all sequences.\n\nExamples::\n    >>> import torch\n    >>> import torch.nn.functional as F\n    >>> from einops import rearrange\n    >>> from ...ops.kda import chunk_kda\n    # inputs with equal lengths (no GVA, HV == H)\n    >>> B, T, H, K, V = 4, 2048, 4, 512, 512\n    >>> q = torch.randn(B, T, H, K, dtype=torch.bfloat16, device='cuda')\n    >>> k = torch.randn(B, T, H, K, dtype=torch.bfloat16, device='cuda')\n    >>> v = torch.randn(B, T, H, V, dtype=torch.bfloat16, device='cuda')\n    >>> beta = torch.rand(B, T, H, dtype=torch.bfloat16, device='cuda')\n    >>> g = torch.rand(B, T, H, K, dtype=torch.bfloat16, device='cuda')\n    >>> h0 = torch.randn(B, H, K, V, dtype=torch.bfloat16, device='cuda')\n    >>> A_log = torch.randn(H, dtype=torch.float32, device='cuda')\n    >>> dt_bias = torch.randn(H * K, dtype=torch.float32, device='cuda')\n    >>> o, ht = chunk_kda(\n        q, k, v, g, beta,\n        A_log=A_log,\n        dt_bias=dt_bias,\n        use_qk_l2norm_in_kernel=True,\n        use_gate_in_kernel=True,\n        initial_state=h0,\n        output_final_state=True\n    )\n    # GVA mode (HV > H)\n    >>> HV = 8  # 2x more value heads than qk heads\n    >>> v = torch.randn(B, T, HV, V, dtype=torch.bfloat16, device='cuda')\n    >>> g = torch.rand(B, T, HV, K, dtype=torch.bfloat16, device='cuda')\n    >>> beta = torch.rand(B, T, HV, dtype=torch.bfloat16, device='cuda')\n    >>> h0 = torch.randn(B, HV, K, V, dtype=torch.bfloat16, device='cuda')\n    >>> A_log = torch.randn(HV, dtype=torch.float32, device='cuda')\n    >>> dt_bias = torch.randn(HV * K, dtype=torch.float32, device='cuda')\n    >>> o, ht = chunk_kda(\n        q, k, v, g, beta,\n        A_log=A_log,\n        dt_bias=dt_bias,\n        use_qk_l2norm_in_kernel=True,\n        use_gate_in_kernel=True,\n        initial_state=h0,\n        output_final_state=True\n    )\n    # for variable-length inputs, the batch size `B` is expected to be 1 and `cu_seqlens` is required\n    >>> q, k, v, beta, g = map(lambda x: rearrange(x, 'b t ... -> 1 (b t) ...'), (q, k, v, beta, g))\n    # for a batch with 4 sequences, `cu_seqlens` with 5 start/end positions are expected\n    >>> cu_seqlens = q.new_tensor([0, 2048, 4096, 6144, 8192], dtype=torch.long)\n    >>> o, ht = chunk_kda(\n        q, k, v, g, beta,\n        A_log=A_log,\n        dt_bias=dt_bias,\n        use_qk_l2norm_in_kernel=True,\n        use_gate_in_kernel=True,\n        initial_state=h0,\n        output_final_state=True,\n        cu_seqlens=cu_seqlens\n    )",
+      "signature": {
+        "parameters": [
+          {
+            "name": "q",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": null,
+            "annotation": "torch.Tensor"
+          },
+          {
+            "name": "k",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": null,
+            "annotation": "torch.Tensor"
+          },
+          {
+            "name": "v",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": null,
+            "annotation": "torch.Tensor"
+          },
+          {
+            "name": "g",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": null,
+            "annotation": "torch.Tensor"
+          },
+          {
+            "name": "beta",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": null,
+            "annotation": "torch.Tensor"
+          },
+          {
+            "name": "scale",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "float | None"
+          },
+          {
+            "name": "initial_state",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "torch.Tensor | None"
+          },
+          {
+            "name": "output_final_state",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "use_qk_l2norm_in_kernel",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "use_gate_in_kernel",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "use_beta_sigmoid_in_kernel",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "allow_neg_eigval",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "safe_gate",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "lower_bound",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "float | None"
+          },
+          {
+            "name": "disable_recompute",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "return_intermediate_states",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "state_v_first",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "cu_seqlens",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "torch.LongTensor | None"
+          },
+          {
+            "name": "cu_seqlens_cpu",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "torch.LongTensor | None"
+          },
+          {
+            "name": "cp_context",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "_fla_xpu_fe2bb66.ops.cp.context.FLACPContext"
+          },
+          {
+            "name": "kwargs",
+            "kind": "VAR_KEYWORD",
+            "default": null,
+            "annotation": null
+          }
+        ],
+        "return_annotation": null
+      }
+    },
+    {
+      "name": "fused_recurrent_kda",
+      "qualname": "fused_recurrent_kda",
+      "module": "_fla_xpu_fe2bb66.ops.kda.fused_recurrent",
+      "kind": "function",
+      "doc": "Args:\n    q (torch.Tensor):\n        queries of shape `[B, T, H, K]`.\n    k (torch.Tensor):\n        keys of shape `[B, T, H, K]`.\n    v (torch.Tensor):\n        values of shape `[B, T, HV, V]`.\n        GVA is applied if `HV > H`.\n    g (torch.Tensor):\n        g (decays) of shape `[B, T, HV, K]`.\n    beta (torch.Tensor):\n        betas of shape `[B, T, HV]`.\n    A_log (Optional[torch.Tensor]):\n        Decay parameter of shape `[HV]`. Required when `use_gate_in_kernel=True`.\n    dt_bias (Optional[torch.Tensor]):\n        Bias added to `g` before activation, of shape `[HV]`.\n        Only used when `use_gate_in_kernel=True`.\n    scale (Optional[float]):\n        Scale factor for the RetNet attention scores.\n        If not provided, it will default to `1 / sqrt(K)`. Default: `None`.\n    initial_state (Optional[torch.Tensor]):\n        Initial state of shape `[N, HV, K, V]` for `N` input sequences.\n        For equal-length input sequences, `N` equals the batch size `B`.\n        Default: `None`.\n    output_final_state (Optional[bool]):\n        Whether to output the final state of shape `[N, HV, K, V]`. Default: `False`.\n    use_qk_l2norm_in_kernel (Optional[bool]):\n        Whether to use L2 normalization in the kernel. Default: `False`.\n    use_gate_in_kernel (Optional[bool]):\n        Whether to compute the log-space KDA decay internally.\n        When `True`, `g` is the raw input and `A_log` must be provided; the kernel fuses\n        gate activation into the recurrence. Default: `False`.\n    use_beta_sigmoid_in_kernel (Optional[bool]):\n        Whether to apply `torch.sigmoid(beta)` inside the kernel.\n        - If `True`, the passed `beta` acts as the raw beta logits.\n        - If `False`, `beta` is expected to already be in post-sigmoid space.\n        Default: `False`.\n    allow_neg_eigval (Optional[bool]):\n        Whether to allow negative eigenvalues by scaling `beta` to `[0, 2)`.\n        Only takes effect together with `use_beta_sigmoid_in_kernel=True`, in which case\n        the kernel computes `2 * sigmoid(beta)` instead of `sigmoid(beta)`. Default: `False`.\n    lower_bound (Optional[float]):\n        Lower bound for the forget gate (in log space). Only used when `use_gate_in_kernel=True`. Default: `None`.\n    state_v_first (Optional[bool]):\n        Store the recurrent state in V-first ``[V, K]`` layout instead of the default ``[K, V]``. Default: ``False``.\n    cu_seqlens (torch.LongTensor):\n        Cumulative sequence lengths of shape `[N+1]` used for variable-length training,\n        consistent with the FlashAttention API.\n\nReturns:\n    o (torch.Tensor):\n        Outputs of shape `[B, T, HV, V]`.\n    final_state (torch.Tensor):\n        Final state of shape `[N, HV, K, V]` if `output_final_state=True` else `None`.\n\nExamples::\n    >>> import torch\n    >>> import torch.nn.functional as F\n    >>> from einops import rearrange\n    >>> from ...ops.kda import fused_recurrent_kda\n    # inputs with equal lengths\n    >>> B, T, H, HV, K, V = 4, 2048, 4, 8, 512, 512\n    >>> q = torch.randn(B, T, H, K, device='cuda')\n    >>> k = F.normalize(torch.randn(B, T, H, K, device='cuda'), p=2, dim=-1)\n    >>> v = torch.randn(B, T, HV, V, device='cuda')\n    >>> g = F.logsigmoid(torch.rand(B, T, HV, K, device='cuda'))\n    >>> beta = torch.rand(B, T, HV, device='cuda').sigmoid()\n    >>> h0 = torch.randn(B, HV, K, V, device='cuda')\n    >>> o, ht = fused_recurrent_kda(\n        q, k, v, g, beta,\n        initial_state=h0,\n        output_final_state=True\n    )\n    # for variable-length inputs, the batch size `B` is expected to be 1 and `cu_seqlens` is required\n    >>> q, k, v, g, beta = map(lambda x: rearrange(x, 'b t ... -> 1 (b t) ...'), (q, k, v, g, beta))\n    # for a batch with 4 sequences, `cu_seqlens` with 5 start/end positions are expected\n    >>> cu_seqlens = q.new_tensor([0, 2048, 4096, 6144, 8192], dtype=torch.long)\n    >>> o_var, ht_var = fused_recurrent_kda(\n        q, k, v, g, beta,\n        initial_state=h0,\n        output_final_state=True,\n        cu_seqlens=cu_seqlens\n    )",
+      "signature": {
+        "parameters": [
+          {
+            "name": "q",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": null,
+            "annotation": "torch.Tensor"
+          },
+          {
+            "name": "k",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": null,
+            "annotation": "torch.Tensor"
+          },
+          {
+            "name": "v",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": null,
+            "annotation": "torch.Tensor"
+          },
+          {
+            "name": "g",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": null,
+            "annotation": "torch.Tensor"
+          },
+          {
+            "name": "beta",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": null,
+            "annotation": "torch.Tensor"
+          },
+          {
+            "name": "A_log",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "torch.Tensor | None"
+          },
+          {
+            "name": "dt_bias",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "torch.Tensor | None"
+          },
+          {
+            "name": "scale",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "float | None"
+          },
+          {
+            "name": "initial_state",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "torch.Tensor"
+          },
+          {
+            "name": "output_final_state",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "use_qk_l2norm_in_kernel",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "use_gate_in_kernel",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "use_beta_sigmoid_in_kernel",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "allow_neg_eigval",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "lower_bound",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "float | None"
+          },
+          {
+            "name": "state_v_first",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "cu_seqlens",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "torch.LongTensor | None"
+          },
+          {
+            "name": "kwargs",
+            "kind": "VAR_KEYWORD",
+            "default": null,
+            "annotation": null
+          }
+        ],
+        "return_annotation": "tuple[torch.Tensor, torch.Tensor]"
+      }
+    },
+    {
+      "name": "chunk_gated_delta_rule",
+      "qualname": "chunk_gated_delta_rule",
+      "module": "_fla_xpu_fe2bb66.ops.gated_delta_rule.chunk",
+      "kind": "function",
+      "doc": "Args:\n    q (torch.Tensor):\n        queries of shape `[B, T, H, K]`.\n    k (torch.Tensor):\n        keys of shape `[B, T, H, K]`.\n    v (torch.Tensor):\n        values of shape `[B, T, HV, V]`.\n        GVA (Grouped Value Attention) is applied if `HV > H`, where `HV` must be divisible by `H`.\n    g (torch.Tensor):\n        (forget) gating tensor of shape `[B, T, HV]`.\n        When `use_gate_in_kernel=False` (default), `g` should be in log space (pre-computed decay).\n        When `use_gate_in_kernel=True`, `g` is the raw input before gate activation;\n        the kernel fuses `-exp(A_log) * softplus(g + dt_bias)` + chunk cumsum internally.\n    beta (torch.Tensor):\n        betas of shape `[B, T, HV]`.\n    scale (Optional[float]):\n        Scale factor for the RetNet attention scores.\n        If not provided, it will default to `1 / sqrt(K)`. Default: `None`.\n    initial_state (Optional[torch.Tensor]):\n        Initial state of shape `[N, HV, K, V]` for `N` input sequences.\n        For equal-length input sequences, `N` equals the batch size `B`.\n        Default: `None`.\n    output_final_state (Optional[bool]):\n        Whether to output the final state of shape `[N, HV, K, V]`. Default: `False`.\n    use_qk_l2norm_in_kernel (bool):\n        Whether to apply L2norm to the q/k tensor internally. Default: `False`.\n    use_gate_in_kernel (bool):\n        Whether to compute the log-space GDN decay internally.\n        When `True`, the passed `g` is the raw input, and `A_log` must be provided.\n        The kernel fuses gate activation + chunk cumsum in a single pass.\n        Default: `False`.\n    A_log (Optional[torch.Tensor]):\n        Decay parameter of shape `[HV]`. Required when `use_gate_in_kernel=True`.\n    dt_bias (Optional[torch.Tensor]):\n        Bias added to `g` before activation, of shape `[HV]`.\n        Only used when `use_gate_in_kernel=True`.\n    use_beta_sigmoid_in_kernel (bool):\n        Whether to apply `torch.sigmoid(beta)` before launching the chunk kernel.\n        - If `True`, the passed `beta` acts as the raw beta logits.\n        - If `False`, `beta` is expected to already be in post-sigmoid space.\n        Default: `False`.\n    allow_neg_eigval (bool):\n        Whether to allow negative eigenvalues by scaling `beta` to `[0, 2)`.\n        Only takes effect together with `use_beta_sigmoid_in_kernel=True`, in which case\n        the kernel computes `2 * sigmoid(beta)` instead of `sigmoid(beta)`. Default: `False`.\n    state_v_first (Optional[bool]):\n        Store the recurrent state in V-first ``[V, K]`` layout instead of the default ``[K, V]``. Default: ``False``.\n    cu_seqlens (torch.LongTensor):\n        Cumulative sequence lengths of shape `[N+1]` used for variable-length training,\n        consistent with the FlashAttention API.\n    cp_context (Optional[FLACPContext]):\n        Context parallel context for distributed training across multiple devices.\n        When provided, `initial_state` and `output_final_state` are not supported,\n        and `cu_seqlens` will be overridden by the context. Default: `None`.\n\nReturns:\n    o (torch.Tensor):\n        Outputs of shape `[B, T, HV, V]`.\n    final_state (torch.Tensor):\n        Final state of shape `[N, HV, K, V]` if `output_final_state=True` else `None`.\n\nExamples::\n    >>> import torch\n    >>> import torch.nn.functional as F\n    >>> from einops import rearrange\n    >>> from ...ops.gated_delta_rule import chunk_gated_delta_rule\n    # inputs with equal lengths\n    >>> B, T, H, HV, K, V = 4, 2048, 4, 8, 512, 512\n    >>> q = torch.randn(B, T, H, K, dtype=torch.bfloat16, device='cuda')\n    >>> k = F.normalize(torch.randn(B, T, H, K, dtype=torch.bfloat16, device='cuda'), p=2, dim=-1)\n    >>> v = torch.randn(B, T, HV, V, dtype=torch.bfloat16, device='cuda')\n    >>> beta = torch.rand(B, T, HV, dtype=torch.bfloat16, device='cuda').sigmoid()\n    >>> g = F.logsigmoid(torch.rand(B, T, HV, dtype=torch.bfloat16, device='cuda'))\n    >>> h0 = torch.randn(B, HV, K, V, dtype=torch.bfloat16, device='cuda')\n    >>> o, ht = chunk_gated_delta_rule(\n        q, k, v, g, beta,\n        initial_state=h0,\n        output_final_state=True\n    )\n    # for variable-length inputs, the batch size `B` is expected to be 1 and `cu_seqlens` is required\n    >>> q, k, v, beta, g = map(lambda x: rearrange(x, 'b t ... -> 1 (b t) ...'), (q, k, v, beta, g))\n    # for a batch with 4 sequences, `cu_seqlens` with 5 start/end positions are expected\n    >>> cu_seqlens = q.new_tensor([0, 2048, 4096, 6144, 8192], dtype=torch.long)\n    >>> o, ht = chunk_gated_delta_rule(\n        q, k, v, g, beta,\n        initial_state=h0,\n        output_final_state=True,\n        cu_seqlens=cu_seqlens\n    )",
+      "signature": {
+        "parameters": [
+          {
+            "name": "q",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": null,
+            "annotation": "torch.Tensor"
+          },
+          {
+            "name": "k",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": null,
+            "annotation": "torch.Tensor"
+          },
+          {
+            "name": "v",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": null,
+            "annotation": "torch.Tensor"
+          },
+          {
+            "name": "g",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": null,
+            "annotation": "torch.Tensor"
+          },
+          {
+            "name": "beta",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": null,
+            "annotation": "torch.Tensor"
+          },
+          {
+            "name": "scale",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "float | None"
+          },
+          {
+            "name": "initial_state",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "torch.Tensor | None"
+          },
+          {
+            "name": "output_final_state",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "use_qk_l2norm_in_kernel",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "use_beta_sigmoid_in_kernel",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "allow_neg_eigval",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "state_v_first",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "cu_seqlens",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "torch.LongTensor | None"
+          },
+          {
+            "name": "cu_seqlens_cpu",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "torch.LongTensor | None"
+          },
+          {
+            "name": "cp_context",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "_fla_xpu_fe2bb66.ops.cp.context.FLACPContext | None"
+          },
+          {
+            "name": "kwargs",
+            "kind": "VAR_KEYWORD",
+            "default": null,
+            "annotation": null
+          }
+        ],
+        "return_annotation": null
+      }
+    },
+    {
+      "name": "fused_recurrent_gated_delta_rule",
+      "qualname": "fused_recurrent_gated_delta_rule",
+      "module": "_fla_xpu_fe2bb66.ops.gated_delta_rule.fused_recurrent",
+      "kind": "function",
+      "doc": "Args:\n    q (torch.Tensor):\n        queries of shape `[B, T, H, K]`.\n    k (torch.Tensor):\n        keys of shape `[B, T, H, K]`.\n    v (torch.Tensor):\n        values of shape `[B, T, HV, V]`.\n        GVA (Grouped Value Attention) is applied if `HV > H`, where `HV` must be divisible by `H`.\n    g (torch.Tensor):\n        g (decays) of shape `[B, T, HV]`. Default: `None`.\n        When `use_gate_in_kernel=False` (default), `g` must be in log space (pre-computed decay).\n        When `use_gate_in_kernel=True`, `g` is the raw pre-activation input; the kernel fuses\n        `-exp(A_log) * softplus(g + dt_bias)` internally per step.\n    gk (torch.Tensor):\n        gk (decays) of shape `[B, T, HV, K]`. Default: `None`.\n    gv (torch.Tensor):\n        gv (decays) of shape `[B, T, HV, V]`. Default: `None`.\n    beta (torch.Tensor):\n        betas of shape `[B, T, HV]`.\n    scale (Optional[float]):\n        Scale factor for the RetNet attention scores.\n        If not provided, it will default to `1 / sqrt(K)`. Default: `None`.\n    initial_state (Optional[torch.Tensor]):\n        Initial state of shape `[N, HV, K, V]` for `N` input sequences.\n        For equal-length input sequences, `N` equals the batch size `B`.\n        Default: `None`.\n    output_final_state (Optional[bool]):\n        Whether to output the final state of shape `[N, HV, K, V]`. Default: `False`.\n    use_qk_l2norm_in_kernel (Optional[bool]):\n        Whether to use L2 normalization in the kernel. Default: `False`.\n    use_gate_in_kernel (bool):\n        Whether to compute the log-space GDN decay internally.\n        When `True`, `g` is the raw input and `A_log` must be provided; the kernel fuses\n        gate activation into the recurrence. Default: `False`.\n    A_log (Optional[torch.Tensor]):\n        Decay parameter of shape `[HV]`. Required when `use_gate_in_kernel=True`.\n    dt_bias (Optional[torch.Tensor]):\n        Bias added to `g` before activation, of shape `[HV]`.\n        Only used when `use_gate_in_kernel=True`.\n    use_beta_sigmoid_in_kernel (Optional[bool]):\n        Whether to apply `torch.sigmoid(beta)` inside the kernel.\n        - If `True`, the passed `beta` acts as the raw beta logits.\n        - If `False`, `beta` is expected to already be in post-sigmoid space.\n        Default: `False`.\n    allow_neg_eigval (Optional[bool]):\n        Whether to allow negative eigenvalues by scaling `beta` to `[0, 2)`.\n        Only takes effect together with `use_beta_sigmoid_in_kernel=True`, in which case\n        the kernel computes `2 * sigmoid(beta)` instead of `sigmoid(beta)`. Default: `False`.\n    state_v_first (Optional[bool]):\n        Store the recurrent state in V-first ``[V, K]`` layout instead of the default ``[K, V]``. Default: ``False``.\n    cu_seqlens (torch.LongTensor):\n        Cumulative sequence lengths of shape `[N+1]` used for variable-length training,\n        consistent with the FlashAttention API.\n\nReturns:\n    o (torch.Tensor):\n        Outputs of shape `[B, T, HV, V]`.\n    final_state (torch.Tensor):\n        Final state of shape `[N, HV, K, V]` if `output_final_state=True` else `None`.\n\nExamples::\n    >>> import torch\n    >>> import torch.nn.functional as F\n    >>> from einops import rearrange\n    >>> from ...ops.gated_delta_rule import fused_recurrent_gated_delta_rule\n    # inputs with equal lengths\n    >>> B, T, H, HV, K, V = 4, 2048, 4, 8, 512, 512\n    >>> q = torch.randn(B, T, H, K, device='cuda')\n    >>> k = F.normalize(torch.randn(B, T, H, K, device='cuda'), p=2, dim=-1)\n    >>> v = torch.randn(B, T, HV, V, device='cuda')\n    >>> g = F.logsigmoid(torch.rand(B, T, HV, device='cuda'))\n    >>> beta = torch.rand(B, T, HV, device='cuda').sigmoid()\n    >>> h0 = torch.randn(B, HV, K, V, device='cuda')\n    >>> o, ht = fused_gated_recurrent_delta_rule(\n        q, k, v, g, beta,\n        initial_state=h0,\n        output_final_state=True\n    )\n    # for variable-length inputs, the batch size `B` is expected to be 1 and `cu_seqlens` is required\n    >>> q, k, v, g, beta = map(lambda x: rearrange(x, 'b t ... -> 1 (b t) ...'), (q, k, v, g, beta))\n    # for a batch with 4 sequences, `cu_seqlens` with 5 start/end positions are expected\n    >>> cu_seqlens = q.new_tensor([0, 2048, 4096, 6144, 8192], dtype=torch.long)\n    >>> o, ht = fused_gated_recurrent_delta_rule(\n        q, k, v, g, beta,\n        initial_state=h0,\n        output_final_state=True,\n        cu_seqlens=cu_seqlens\n    )",
+      "signature": {
+        "parameters": [
+          {
+            "name": "q",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": null,
+            "annotation": "torch.Tensor"
+          },
+          {
+            "name": "k",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": null,
+            "annotation": "torch.Tensor"
+          },
+          {
+            "name": "v",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": null,
+            "annotation": "torch.Tensor"
+          },
+          {
+            "name": "g",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "torch.Tensor | None"
+          },
+          {
+            "name": "gk",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "torch.Tensor | None"
+          },
+          {
+            "name": "gv",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "torch.Tensor | None"
+          },
+          {
+            "name": "beta",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "torch.Tensor | None"
+          },
+          {
+            "name": "scale",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "float"
+          },
+          {
+            "name": "initial_state",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "torch.Tensor"
+          },
+          {
+            "name": "output_final_state",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "use_qk_l2norm_in_kernel",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "use_gate_in_kernel",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "A_log",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "torch.Tensor | None"
+          },
+          {
+            "name": "dt_bias",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "torch.Tensor | None"
+          },
+          {
+            "name": "use_beta_sigmoid_in_kernel",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "allow_neg_eigval",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "state_v_first",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "False",
+            "annotation": "bool"
+          },
+          {
+            "name": "cu_seqlens",
+            "kind": "POSITIONAL_OR_KEYWORD",
+            "default": "None",
+            "annotation": "torch.LongTensor | None"
+          },
+          {
+            "name": "kwargs",
+            "kind": "VAR_KEYWORD",
+            "default": null,
+            "annotation": null
+          }
+        ],
+        "return_annotation": "tuple[torch.Tensor, torch.Tensor]"
+      }
+    }
+  ],
+  "layers": [
+    {
+      "name": "FusedRMSNormGated",
+      "qualname": "FusedRMSNormGated",
+      "module": "_fla_xpu_fe2bb66.layers",
+      "kind": "class",
+      "doc": "Base class for all neural network modules.\n\nYour models should also subclass this class.\n\nModules can also contain other Modules, allowing them to be nested in\na tree structure. You can assign the submodules as regular attributes::\n\n    import torch.nn as nn\n    import torch.nn.functional as F\n\n\n    class Model(nn.Module):\n        def __init__(self) -> None:\n            super().__init__()\n            self.conv1 = nn.Conv2d(1, 20, 5)\n            self.conv2 = nn.Conv2d(20, 20, 5)\n\n        def forward(self, x):\n            x = F.relu(self.conv1(x))\n            return F.relu(self.conv2(x))\n\nSubmodules assigned in this way will be registered, and will also have their\nparameters converted when you call :meth:`to`, etc.\n\n.. note::\n    As per the example above, an ``__init__()`` call to the parent class\n    must be made before assignment on the child.\n\n:ivar training: Boolean represents whether this module is in training or\n                evaluation mode.\n:vartype training: bool",
+      "signature": {
+        "parameters": [
+          {
+            "name": "args",
+            "kind": "VAR_POSITIONAL",
+            "default": null,
+            "annotation": "Any"
+          },
+          {
+            "name": "kwargs",
+            "kind": "VAR_KEYWORD",
+            "default": null,
+            "annotation": "Any"
+          }
+        ],
+        "return_annotation": "None"
+      },
+      "attributes": {
+        "has_backward": null,
+        "can_torch_compile": null
+      }
+    },
+    {
+      "name": "chunk_kimi_delta_attention",
+      "qualname": "chunk_kimi_delta_attention",
+      "module": "_fla_xpu_fe2bb66.layers",
+      "kind": "class",
+      "doc": "Base class for all neural network modules.\n\nYour models should also subclass this class.\n\nModules can also contain other Modules, allowing them to be nested in\na tree structure. You can assign the submodules as regular attributes::\n\n    import torch.nn as nn\n    import torch.nn.functional as F\n\n\n    class Model(nn.Module):\n        def __init__(self) -> None:\n            super().__init__()\n            self.conv1 = nn.Conv2d(1, 20, 5)\n            self.conv2 = nn.Conv2d(20, 20, 5)\n\n        def forward(self, x):\n            x = F.relu(self.conv1(x))\n            return F.relu(self.conv2(x))\n\nSubmodules assigned in this way will be registered, and will also have their\nparameters converted when you call :meth:`to`, etc.\n\n.. note::\n    As per the example above, an ``__init__()`` call to the parent class\n    must be made before assignment on the child.\n\n:ivar training: Boolean represents whether this module is in training or\n                evaluation mode.\n:vartype training: bool",
+      "signature": {
+        "parameters": [
+          {
+            "name": "args",
+            "kind": "VAR_POSITIONAL",
+            "default": null,
+            "annotation": "Any"
+          },
+          {
+            "name": "kwargs",
+            "kind": "VAR_KEYWORD",
+            "default": null,
+            "annotation": "Any"
+          }
+        ],
+        "return_annotation": "None"
+      },
+      "attributes": {
+        "has_backward": null,
+        "can_torch_compile": null
+      }
+    },
+    {
+      "name": "recurrent_kimi_delta_attention",
+      "qualname": "recurrent_kimi_delta_attention",
+      "module": "_fla_xpu_fe2bb66.layers",
+      "kind": "class",
+      "doc": "Base class for all neural network modules.\n\nYour models should also subclass this class.\n\nModules can also contain other Modules, allowing them to be nested in\na tree structure. You can assign the submodules as regular attributes::\n\n    import torch.nn as nn\n    import torch.nn.functional as F\n\n\n    class Model(nn.Module):\n        def __init__(self) -> None:\n            super().__init__()\n            self.conv1 = nn.Conv2d(1, 20, 5)\n            self.conv2 = nn.Conv2d(20, 20, 5)\n\n        def forward(self, x):\n            x = F.relu(self.conv1(x))\n            return F.relu(self.conv2(x))\n\nSubmodules assigned in this way will be registered, and will also have their\nparameters converted when you call :meth:`to`, etc.\n\n.. note::\n    As per the example above, an ``__init__()`` call to the parent class\n    must be made before assignment on the child.\n\n:ivar training: Boolean represents whether this module is in training or\n                evaluation mode.\n:vartype training: bool",
+      "signature": {
+        "parameters": [
+          {
+            "name": "args",
+            "kind": "VAR_POSITIONAL",
+            "default": null,
+            "annotation": "Any"
+          },
+          {
+            "name": "kwargs",
+            "kind": "VAR_KEYWORD",
+            "default": null,
+            "annotation": "Any"
+          }
+        ],
+        "return_annotation": "None"
+      },
+      "attributes": {
+        "has_backward": null,
+        "can_torch_compile": null
+      }
+    },
+    {
+      "name": "chunk_gated_delta_rule",
+      "qualname": "chunk_gated_delta_rule",
+      "module": "_fla_xpu_fe2bb66.layers",
+      "kind": "class",
+      "doc": "Base class for all neural network modules.\n\nYour models should also subclass this class.\n\nModules can also contain other Modules, allowing them to be nested in\na tree structure. You can assign the submodules as regular attributes::\n\n    import torch.nn as nn\n    import torch.nn.functional as F\n\n\n    class Model(nn.Module):\n        def __init__(self) -> None:\n            super().__init__()\n            self.conv1 = nn.Conv2d(1, 20, 5)\n            self.conv2 = nn.Conv2d(20, 20, 5)\n\n        def forward(self, x):\n            x = F.relu(self.conv1(x))\n            return F.relu(self.conv2(x))\n\nSubmodules assigned in this way will be registered, and will also have their\nparameters converted when you call :meth:`to`, etc.\n\n.. note::\n    As per the example above, an ``__init__()`` call to the parent class\n    must be made before assignment on the child.\n\n:ivar training: Boolean represents whether this module is in training or\n                evaluation mode.\n:vartype training: bool",
+      "signature": {
+        "parameters": [
+          {
+            "name": "args",
+            "kind": "VAR_POSITIONAL",
+            "default": null,
+            "annotation": "Any"
+          },
+          {
+            "name": "kwargs",
+            "kind": "VAR_KEYWORD",
+            "default": null,
+            "annotation": "Any"
+          }
+        ],
+        "return_annotation": "None"
+      },
+      "attributes": {
+        "has_backward": null,
+        "can_torch_compile": null
+      }
+    },
+    {
+      "name": "recurrent_gated_delta_rule",
+      "qualname": "recurrent_gated_delta_rule",
+      "module": "_fla_xpu_fe2bb66.layers",
+      "kind": "class",
+      "doc": "Base class for all neural network modules.\n\nYour models should also subclass this class.\n\nModules can also contain other Modules, allowing them to be nested in\na tree structure. You can assign the submodules as regular attributes::\n\n    import torch.nn as nn\n    import torch.nn.functional as F\n\n\n    class Model(nn.Module):\n        def __init__(self) -> None:\n            super().__init__()\n            self.conv1 = nn.Conv2d(1, 20, 5)\n            self.conv2 = nn.Conv2d(20, 20, 5)\n\n        def forward(self, x):\n            x = F.relu(self.conv1(x))\n            return F.relu(self.conv2(x))\n\nSubmodules assigned in this way will be registered, and will also have their\nparameters converted when you call :meth:`to`, etc.\n\n.. note::\n    As per the example above, an ``__init__()`` call to the parent class\n    must be made before assignment on the child.\n\n:ivar training: Boolean represents whether this module is in training or\n                evaluation mode.\n:vartype training: bool",
+      "signature": {
+        "parameters": [
+          {
+            "name": "args",
+            "kind": "VAR_POSITIONAL",
+            "default": null,
+            "annotation": "Any"
+          },
+          {
+            "name": "kwargs",
+            "kind": "VAR_KEYWORD",
+            "default": null,
+            "annotation": "Any"
+          }
+        ],
+        "return_annotation": "None"
+      },
+      "attributes": {
+        "has_backward": null,
+        "can_torch_compile": null
+      }
+    }
+  ]
+}