----- 持续更新
SWA （Sliding Window Attention）
改方法来自于mistral-7B论文，该方法假设：生成序列只与前n个路口相关，与前序太远的token无关。处理局部依赖任务（如文本生成）更高效，不适合全局依赖任务（如摘要）。时间复杂度为 O （ N W ） O（NW） O（NW）
由于我们的场景中序列长度最长不超过300，序列长度比较短，效果基本持平，效率没有提升；可以再尝试将起终点信息的mask去掉。
(1) 注意力范围限制
固定窗口大小：设定一个窗口大小 w，每个 token 仅能关注其前后各 w/2个 token（或仅左侧，取决于任务类型，如自回归生成）。滑动窗口的移动：窗口随 token 位置滑动，但窗口大小固定（如 w=4096）。
(2) 掩码（Mask）设计
通过二进制掩码矩阵强制模型忽略窗口外的 token：
# 示例：生成滑动窗口掩码（PyTorch 伪代码）
seq_len = 8192 # 输入序列长度
window_size = 4096
mask = torch.zeros(seq_len, seq_len) # 初始化全零掩码for i in range(seq_len):start = max(0, i - window_size // 2)end = min(seq_len, i + window_size // 2)mask[i, start:end] = 1 # 窗口内设为可见（1）# 结合因果掩码（自回归生成场景）
causal_mask = torch.triu(torch.ones(seq_len, seq_len), diagonal=1).bool()
final_mask = mask & ~causal_mask # 窗口内且非未来位置
(3) 分层扩展感受野
多层的窗口叠加：通过堆叠多个注意力层，每个层的窗口覆盖局部区域，高层神经元间接融合更大范围的信息。例如：假设每层窗口大小为 4096，堆叠 4 层后，理论感受野可达 4096x4=16384 token。
（4）高效计算技巧：
- 块计算（Block Computation）：将长序列切分为多个块，逐块计算注意力，避免一次性处理全序列。
- FlashAttention 结合：利用 FlashAttention 的硬件优化加速窗口内注意力计算。
# 示例：使用 FlashAttention 的滑动窗口（伪代码）
from flash_attn import flash_attn_qkvpacked_funcq = ... # Query 向量
k = ... # Key 向量
v = ... # Value 向量
window_mask = ... # 滑动窗口掩码# 应用滑动窗口掩码
attn_output = flash_attn_qkvpacked_func(q, k, v,softmax_scale=1.0,causal=True, # 自回归生成需启用因果掩码window_size=window_size # 直接指定窗口大小
)
问题
这个SWA代码看起来只是额外计算了一个mask矩阵，加入到原矩阵上进行attention计算，计算复杂度并没有改变吧？反而增加了一个构造mask矩阵的时间。有清楚的朋友可以帮忙解答一下吗
问deepseek：
deepseek说我的猜想是没问题的，
您提出的问题非常关键！您是对的——如果直接在完整的注意力矩阵上应用滑动窗口掩码，计算复杂度仍然是 O （ n 2 ） O（n^2） O（n2），因为即使掩码将窗口外的值设为负无穷，模型仍然需要计算所有位置的注意力分数。这与 Sliding Window Attention（SWA）的理论设计目标复杂度 O （ n w ） O（nw） O（nw）存在矛盾。
实际高效的 SWA 需直接跳过窗口外的计算，仅处理窗口内的 token。以下是两种主流实现方案：
方案 1：分块计算（Block-wise Computation）
将长序列切分为多个块（Block），每个块内独立计算注意力，避免全局矩阵操作。
import torch
from einops import rearrangedef block_swa(q, k, v, window_size):# 输入 q, k, v: [batch, seq_len, heads, dim]batch, seq_len, heads, dim = q.shape# 分块（假设 seq_len 是 window_size 的整数倍）q_blocks = rearrange(q, 'b (n w) h d -> b n w h d', w=window_size)k_blocks = rearrange(k, 'b (n w) h d -> b n w h d', w=window_size)v_blocks = rearrange(v, 'b (n w) h d -> b n w h d', w=window_size)# 块内注意力计算（复杂度 O(n * w^2)）attn = torch.einsum('bnqhd,bnkhd->bnhqk', q_blocks, k_blocks) / (dim ** 0.5)attn = torch.softmax(attn, dim=-1)out_blocks = torch.einsum('bnhqk,bnkhd->bnqhd', attn, v_blocks)# 合并块out = rearrange(out_blocks, 'b n w h d -> b (n w) h d')return out
方案 2：稀疏注意力计算（Sparse Attention）
直接为每个查询（Query）位置仅计算窗口内的键（Key）和值（Value），跳过无关位置。
def sparse_swa(q, k, v, window_size):batch, seq_len, heads, dim = q.shapeoutput = torch.zeros_like(q)for i in range(seq_len):# 确定窗口边界start = max(0, i - window_size // 2)end = min(seq_len, i + window_size // 2)# 收集窗口内的 k 和 v [batch, heads, window_size, dim]k_window = k[:, start:end, :, :]v_window = v[:, start:end, :, :]# 计算当前查询位置的注意力q_i = q[:, i, :, :] # [batch, heads, dim]attn_scores = torch.einsum('bhd,bhwd->bhw', q_i, k_window) / (dim ** 0.5)attn_weights = torch.softmax(attn_scores, dim=-1)# 加权求和output[:, i, :, :] = torch.einsum('bhw,bhwd->bhd', attn_weights, v_window)return output
复杂度：O(n×w)（严格符合理论值）。
局限性：循环操作在 GPU 上效率低，需用 CUDA 内核优化。
实际方案：FlashAttention支持直接指定窗口大小，自动跳过窗口外计算，无需显式分块或循环： 若需自行实现 SWA，建议优先使用优化库（如 FlashAttention），避免手动处理复杂的分块和索引逻辑。
# 使用 FlashAttention 的滑动窗口模式
from flash_attn import flash_attn_funcoutput = flash_attn_func(q, k, v,causal=True,window_size=window_size # 直接限制窗口大小
)
