wehub-resource-sync
361 lines
12 KiB
Python
361 lines
12 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Copyright (c) 2025, HUAWEI CORPORATION. All rights reserved.
|
|
# Copyright (c) 2023-2025, Songlin Yang, Yu Zhang
|
|
|
|
import torch
|
|
import warnings
|
|
from mindspeed.ops.triton.chunk_delta_h import chunk_gated_delta_rule_bwd_dhu, chunk_gated_delta_rule_fwd_h
|
|
from mindspeed.ops.triton.chunk_o import chunk_bwd_dqkwg, chunk_bwd_dv_local, chunk_fwd_o
|
|
from mindspeed.ops.triton.chunk_scaled_dot_kkt import chunk_scaled_dot_kkt_fwd
|
|
from mindspeed.ops.triton.cumsum import chunk_local_cumsum
|
|
from mindspeed.ops.triton.solve_tril import solve_tril
|
|
from mindspeed.ops.triton.utils import autocast_custom_bwd, autocast_custom_fwd, input_guard
|
|
from mindspeed.ops.triton.wy_fast import prepare_wy_repr_bwd, recompute_w_u_fwd
|
|
from typing import Optional
|
|
|
|
|
|
def _torch_l2norm_fwd(
|
|
x: torch.Tensor,
|
|
eps: float = 1e-6,
|
|
output_dtype: Optional[torch.dtype] = None,
|
|
):
|
|
x_shape_og = x.shape
|
|
x = x.view(-1, x.shape[-1])
|
|
x_float = x.float()
|
|
rstd = torch.rsqrt(torch.sum(x_float * x_float, dim=-1) + eps)
|
|
y = x_float * rstd.unsqueeze(-1)
|
|
y = y.to(output_dtype if output_dtype is not None else x.dtype)
|
|
return y.view(x_shape_og), rstd.view(x_shape_og[:-1])
|
|
|
|
|
|
def _torch_l2norm_bwd(
|
|
y: torch.Tensor,
|
|
rstd: torch.Tensor,
|
|
dy: torch.Tensor,
|
|
eps: float = 1e-6,
|
|
):
|
|
y_shape_og = y.shape
|
|
y = y.view(-1, y.shape[-1])
|
|
dy = dy.view(-1, dy.shape[-1])
|
|
y_float = y.float()
|
|
dy_float = dy.float()
|
|
rstd = rstd.view(-1).float()
|
|
dx = dy_float * rstd.unsqueeze(-1)
|
|
dx = dx - torch.sum(dy_float * y_float, dim=-1, keepdim=True) * y_float * rstd.unsqueeze(-1)
|
|
return dx.to(y.dtype).view(y_shape_og)
|
|
|
|
|
|
def chunk_gated_delta_rule_fwd(
|
|
q: torch.Tensor,
|
|
k: torch.Tensor,
|
|
v: torch.Tensor,
|
|
g: torch.Tensor,
|
|
beta: torch.Tensor,
|
|
scale: float,
|
|
initial_state: torch.Tensor,
|
|
output_final_state: bool,
|
|
cu_seqlens: Optional[torch.LongTensor] = None,
|
|
chunk_size: int = 64,
|
|
):
|
|
g = chunk_local_cumsum(g, chunk_size=chunk_size, cu_seqlens=cu_seqlens, head_first=False)
|
|
# obtain WY representation. u is actually the new v.
|
|
A = chunk_scaled_dot_kkt_fwd(
|
|
k=k, g=g, beta=beta, cu_seqlens=cu_seqlens, chunk_size=chunk_size, output_dtype=torch.float32)
|
|
A = solve_tril(A=A, cu_seqlens=cu_seqlens, output_dtype=k.dtype)
|
|
w, u = recompute_w_u_fwd(
|
|
k=k,
|
|
v=v,
|
|
beta=beta,
|
|
A=A,
|
|
g=g,
|
|
cu_seqlens=cu_seqlens,
|
|
)
|
|
h, v_new, final_state = chunk_gated_delta_rule_fwd_h(
|
|
k=k,
|
|
w=w,
|
|
u=u,
|
|
g=g,
|
|
initial_state=initial_state,
|
|
output_final_state=output_final_state,
|
|
chunk_size=chunk_size,
|
|
cu_seqlens=cu_seqlens,
|
|
)
|
|
o = chunk_fwd_o(
|
|
q=q,
|
|
k=k,
|
|
v=v_new,
|
|
h=h,
|
|
g=g,
|
|
scale=scale,
|
|
cu_seqlens=cu_seqlens,
|
|
chunk_size=chunk_size,
|
|
)
|
|
return g, o, A, final_state
|
|
|
|
|
|
def chunk_gated_delta_rule_bwd(
|
|
q: torch.Tensor,
|
|
k: torch.Tensor,
|
|
v: torch.Tensor,
|
|
g: torch.Tensor,
|
|
beta: torch.Tensor,
|
|
A: torch.Tensor,
|
|
scale: float,
|
|
initial_state: torch.Tensor,
|
|
do: torch.Tensor,
|
|
dht: torch.Tensor,
|
|
cu_seqlens: Optional[torch.LongTensor] = None,
|
|
chunk_size: int = 64,
|
|
):
|
|
w, u = recompute_w_u_fwd(
|
|
k=k,
|
|
v=v,
|
|
beta=beta,
|
|
A=A,
|
|
g=g,
|
|
cu_seqlens=cu_seqlens,
|
|
)
|
|
h, v_new, _ = chunk_gated_delta_rule_fwd_h(
|
|
k=k,
|
|
w=w,
|
|
u=u,
|
|
g=g,
|
|
initial_state=initial_state,
|
|
output_final_state=False,
|
|
cu_seqlens=cu_seqlens,
|
|
chunk_size=chunk_size,
|
|
)
|
|
dv = chunk_bwd_dv_local(
|
|
q=q,
|
|
k=k,
|
|
g=g,
|
|
do=do,
|
|
scale=scale,
|
|
cu_seqlens=cu_seqlens,
|
|
chunk_size=chunk_size,
|
|
)
|
|
dh, dh0, dv = chunk_gated_delta_rule_bwd_dhu(
|
|
q=q,
|
|
k=k,
|
|
w=w,
|
|
g=g,
|
|
h0=initial_state,
|
|
dht=dht,
|
|
do=do,
|
|
dv=dv,
|
|
scale=scale,
|
|
cu_seqlens=cu_seqlens,
|
|
chunk_size=chunk_size,
|
|
)
|
|
dq, dk, dw, dg = chunk_bwd_dqkwg(
|
|
q=q,
|
|
k=k,
|
|
v=v_new,
|
|
w=w,
|
|
g=g,
|
|
h=h,
|
|
dv=dv,
|
|
do=do,
|
|
dh=dh,
|
|
chunk_size=chunk_size,
|
|
scale=scale,
|
|
cu_seqlens=cu_seqlens,
|
|
)
|
|
dk2, dv, db, dg2 = prepare_wy_repr_bwd(
|
|
k=k, v=v, beta=beta, g=g, A=A, dw=dw, du=dv, cu_seqlens=cu_seqlens, chunk_size=chunk_size)
|
|
dk.add_(dk2)
|
|
dg.add_(dg2)
|
|
if dg.dtype != torch.float32:
|
|
raise ValueError(f'dg current type is {dg.dtype} , should be float32')
|
|
dg = chunk_local_cumsum(dg, chunk_size=chunk_size, reverse=True, cu_seqlens=cu_seqlens, head_first=False)
|
|
return dq, dk, dv, db, dg, dh0
|
|
|
|
|
|
class ChunkGatedDeltaRuleFunction(torch.autograd.Function):
|
|
|
|
@staticmethod
|
|
@input_guard
|
|
@autocast_custom_fwd
|
|
def forward(
|
|
ctx,
|
|
q: torch.Tensor,
|
|
k: torch.Tensor,
|
|
v: torch.Tensor,
|
|
g: torch.Tensor,
|
|
beta: torch.Tensor,
|
|
scale: float,
|
|
initial_state: torch.Tensor,
|
|
output_final_state: bool,
|
|
cu_seqlens: Optional[torch.LongTensor] = None,
|
|
use_qk_l2norm_in_kernel: bool = False,
|
|
chunk_size: int = 64,
|
|
):
|
|
if use_qk_l2norm_in_kernel:
|
|
q, q_rstd = _torch_l2norm_fwd(q)
|
|
k, k_rstd = _torch_l2norm_fwd(k)
|
|
else:
|
|
q_rstd, k_rstd = None, None
|
|
|
|
g, o, A, final_state = chunk_gated_delta_rule_fwd(
|
|
q=q,
|
|
k=k,
|
|
v=v,
|
|
g=g,
|
|
beta=beta,
|
|
scale=scale,
|
|
initial_state=initial_state,
|
|
output_final_state=output_final_state,
|
|
cu_seqlens=cu_seqlens,
|
|
chunk_size=chunk_size)
|
|
ctx.save_for_backward(q, q_rstd, k, k_rstd, v, g, beta, A, initial_state, cu_seqlens)
|
|
ctx.scale = scale
|
|
ctx.use_qk_l2norm_in_kernel = use_qk_l2norm_in_kernel
|
|
ctx.chunk_size = chunk_size
|
|
return o.to(q.dtype), final_state
|
|
|
|
@staticmethod
|
|
@input_guard
|
|
@autocast_custom_bwd
|
|
def backward(ctx, do: torch.Tensor, dht: torch.Tensor):
|
|
q, q_rstd, k, k_rstd, v, g, beta, A, initial_state, cu_seqlens = ctx.saved_tensors
|
|
dq, dk, dv, db, dg, dh0 = chunk_gated_delta_rule_bwd(
|
|
q=q,
|
|
k=k,
|
|
v=v,
|
|
g=g,
|
|
beta=beta,
|
|
A=A,
|
|
scale=ctx.scale,
|
|
initial_state=initial_state,
|
|
do=do,
|
|
dht=dht,
|
|
cu_seqlens=cu_seqlens,
|
|
chunk_size=ctx.chunk_size,
|
|
)
|
|
if ctx.use_qk_l2norm_in_kernel:
|
|
dq = _torch_l2norm_bwd(q, q_rstd, dq)
|
|
dk = _torch_l2norm_bwd(k, k_rstd, dk)
|
|
return dq.to(q), dk.to(k), dv.to(v), dg.to(g), db.to(beta), None, dh0, None, None, None, None
|
|
|
|
|
|
@torch.compiler.disable
|
|
def chunk_gated_delta_rule(
|
|
q: torch.Tensor,
|
|
k: torch.Tensor,
|
|
v: torch.Tensor,
|
|
g: torch.Tensor,
|
|
beta: torch.Tensor,
|
|
scale: float = None,
|
|
initial_state: torch.Tensor = None,
|
|
output_final_state: bool = False,
|
|
use_qk_l2norm_in_kernel: bool = False,
|
|
cu_seqlens: Optional[torch.LongTensor] = None,
|
|
chunk_size: int = 64,
|
|
head_first: bool = False,
|
|
):
|
|
r"""
|
|
Args:
|
|
q (torch.Tensor):
|
|
queries of shape `[B, T, H, K]`.
|
|
k (torch.Tensor):
|
|
keys of shape `[B, T, H, K]`.
|
|
v (torch.Tensor):
|
|
values of shape `[B, T, H, V]`.
|
|
g (torch.Tensor):
|
|
(forget) gating tensor (in log space!) of shape `[B, T, H]`.
|
|
beta (torch.Tensor):
|
|
betas of shape `[B, T, H]`.
|
|
scale (Optional[float]):
|
|
Scale factor for the RetNet attention scores.
|
|
If not provided, it will default to `1 / sqrt(K)`. Default: `None`.
|
|
initial_state (Optional[torch.Tensor]):
|
|
Initial state of shape `[N, H, K, V]` for `N` input sequences.
|
|
For equal-length input sequences, `N` equals the batch size `B`.
|
|
Default: `None`.
|
|
output_final_state (Optional[bool]):
|
|
Whether to output the final state of shape `[N, H, K, V]`. Default: `False`.
|
|
use_qk_l2norm_in_kernel (bool):
|
|
Whether to apply L2norm to the q/k tensor internally. Default: `False`.
|
|
cu_seqlens (torch.LongTensor):
|
|
Cumulative sequence lengths of shape `[N+1]` used for variable-length training,
|
|
consistent with the FlashAttention API.
|
|
head_first (Optional[bool]):
|
|
Whether the inputs are in the head-first format. Default: `False`.
|
|
This argument has been deprecated.
|
|
|
|
Returns:
|
|
o (torch.Tensor):
|
|
Outputs of shape `[B, T, H, V]`.
|
|
final_state (torch.Tensor):
|
|
Final state of shape `[N, H, K, V]` if `output_final_state=True` else `None`.
|
|
|
|
Examples::
|
|
>>> import torch
|
|
>>> import torch.nn.functional as F
|
|
>>> from einops import rearrange
|
|
>>> from fla.ops.gated_delta_rule import chunk_gated_delta_rule
|
|
# inputs with equal lengths
|
|
>>> B, T, H, K, V = 4, 2048, 4, 512, 512
|
|
>>> q = torch.randn(B, T, H, K, dtype=torch.bfloat16, device='cuda')
|
|
>>> k = F.normalize(torch.randn(B, T, H, K, dtype=torch.bfloat16, device='cuda'), p=2, dim=-1)
|
|
>>> v = torch.randn(B, T, H, V, dtype=torch.bfloat16, device='cuda')
|
|
>>> beta = torch.rand(B, T, H, dtype=torch.bfloat16, device='cuda').sigmoid()
|
|
>>> g = F.logsigmoid(torch.rand(B, T, H, dtype=torch.bfloat16, device='cuda'))
|
|
>>> h0 = torch.randn(B, H, K, V, dtype=torch.bfloat16, device='cuda')
|
|
>>> o, ht = chunk_gated_delta_rule(
|
|
q, k, v, g, beta,
|
|
initial_state=h0,
|
|
output_final_state=True
|
|
)
|
|
# for variable-length inputs, the batch size `B` is expected to be 1 and `cu_seqlens` is required
|
|
>>> q, k, v, beta, g = map(lambda x: rearrange(x, 'b t ... -> 1 (b t) ...'), (q, k, v, beta, g))
|
|
# for a batch with 4 sequences, `cu_seqlens` with 5 start/end positions are expected
|
|
>>> cu_seqlens = q.new_tensor([0, 2048, 4096, 6144, 8192], dtype=torch.long)
|
|
>>> o, ht = chunk_gated_delta_rule(
|
|
q, k, v, g, beta,
|
|
initial_state=h0,
|
|
output_final_state=True,
|
|
cu_seqlens=cu_seqlens
|
|
)
|
|
"""
|
|
if q.dtype != k.dtype or k.dtype != v.dtype:
|
|
raise ValueError(
|
|
f'q current type is {q.dtype}, k current type is {k.dtype}, v current type is {v.dtype}, should be equal')
|
|
if q.dtype == torch.float32:
|
|
raise ValueError('ChunkGatedDeltaRuleFunction does not support float32. Please use bfloat16.')
|
|
if len(beta.shape) != 3:
|
|
raise ValueError(f'beta current shape len is {len(beta.shape)}, beta must be of shape [B, T, H] '
|
|
f'if head_first=False, or [B, H, T] otherwise.')
|
|
if head_first:
|
|
warnings.warn('head_first is deprecated and will be removed in a future version. '
|
|
'Please use head_first=False for now instead.')
|
|
if not head_first and q.shape[1] < q.shape[2]:
|
|
warnings.warn(
|
|
f'Input tensor shape suggests format mismatch: seq_len ({q.shape[1]}) < num_heads ({q.shape[2]}). '
|
|
'This may indicate the inputs were passed in head-first format [B, H, T, ...] '
|
|
'when head_first=False was specified. '
|
|
'Please verify your input tensor format matches the expected shape [B, T, H, ...].')
|
|
if cu_seqlens is not None:
|
|
if q.shape[0] != 1:
|
|
raise ValueError(f'The batch size is expected to be 1 rather than {q.shape[0]} when using `cu_seqlens`.'
|
|
f'Please flatten variable-length inputs before processing.')
|
|
if initial_state is not None and initial_state.shape[0] != len(cu_seqlens) - 1:
|
|
raise ValueError(f'The number of initial states is expected to be equal to the number of input sequences, '
|
|
f'i.e., {len(cu_seqlens) - 1} rather than {initial_state.shape[0]}.')
|
|
if scale is None:
|
|
scale = k.shape[-1]**-0.5
|
|
o, final_state = ChunkGatedDeltaRuleFunction.apply(
|
|
q,
|
|
k,
|
|
v,
|
|
g,
|
|
beta,
|
|
scale,
|
|
initial_state,
|
|
output_final_state,
|
|
cu_seqlens,
|
|
use_qk_l2norm_in_kernel,
|
|
chunk_size,
|
|
)
|
|
return o, final_state
|