# -*- coding: utf-8 -*-
"""手写多头注意力 —— 与视频第 2~4 部分一一对应的可运行实现。

三个类：
  CausalSelfAttention     上一期的单头（d_k = 64）
  MultiHeadAttention      4 个独立的头，nn.ModuleList 循环（视频第二部分）
  MultiHeadAttentionBatch 四维张量 + 一次批矩阵乘（视频第四部分，工业写法）

运行：python multihead_attention.py
它会做三件事：
  1. 打印三种写法的输出形状与参数量，核对视频里的参数账；
  2. 把 ModuleList 版 4 个头的权重拼成 64×64 赋给批处理版，
     验证两种写法的输出在数值上一致（只差浮点舍入）；
  3. 跑一遍因果掩码检查，确认每个位置看不到未来。

依赖：torch（CPU 即可）。
"""
import math

import torch
import torch.nn as nn
import torch.nn.functional as F

# ---- 与视频一致的超参（第 1 部分：4×5×64 的输入）------------------------
N_EMBD = 64      # d_model
N_HEAD = 4       # 4 个头
HEAD_SIZE = N_EMBD // N_HEAD   # = 16
BLOCK = 5        # 视频示例的序列长度 = 5
BATCH = 4        # 4 条样本


# ======================================================================
# 1. 上一期的单头注意力（d_k = 64）
# ======================================================================
class CausalSelfAttention(nn.Module):
    """单头因果自注意力：一组 Q/K/V，缩放用 sqrt(64)。"""

    def __init__(self, n_embd=N_EMBD):
        super().__init__()
        self.qkv = nn.Linear(n_embd, 3 * n_embd, bias=False)
        self.proj = nn.Linear(n_embd, n_embd, bias=False)
        self.register_buffer("tril", torch.tril(torch.ones(BLOCK, BLOCK)))

    def forward(self, x):
        B, T, C = x.shape
        q, k, v = self.qkv(x).chunk(3, dim=-1)          # 各 (B, T, 64)
        att = q @ k.transpose(-2, -1)                     # (B, T, T)
        att = att * (1.0 / math.sqrt(C))                  # 除以 sqrt(64) = 8
        att = att.masked_fill(self.tril[:T, :T] == 0, float("-inf"))
        att = F.softmax(att, dim=-1)
        return self.proj(att @ v)


# ======================================================================
# 2. 多头：4 个独立的头（视频第二部分的“最直观写法”）
# ======================================================================
class Head(nn.Module):
    """单个注意力头：把完整的 64 维输入投影成 16 维的 Q/K/V。"""

    def __init__(self, n_embd=N_EMBD, head_size=HEAD_SIZE):
        super().__init__()
        # 注意：输入是完整 64 维，不是把输入劈成四段
        self.key = nn.Linear(n_embd, head_size, bias=False)
        self.query = nn.Linear(n_embd, head_size, bias=False)
        self.value = nn.Linear(n_embd, head_size, bias=False)
        self.register_buffer("tril", torch.tril(torch.ones(BLOCK, BLOCK)))

    def forward(self, x):
        B, T, C = x.shape
        q, k, v = self.query(x), self.key(x), self.value(x)   # 各 (B, T, 16)
        att = q @ k.transpose(-2, -1)                          # (B, T, T)
        att = att * (1.0 / math.sqrt(k.shape[-1]))             # 除以 sqrt(16) = 4
        att = att.masked_fill(self.tril[:T, :T] == 0, float("-inf"))
        att = F.softmax(att, dim=-1)
        return att @ v                                         # (B, T, 16)


class MultiHeadAttention(nn.Module):
    """4 个头各自算，最后在最后一维拼接，再过 64×64 的输出投影。"""

    def __init__(self, n_embd=N_EMBD, n_head=N_HEAD):
        super().__init__()
        self.heads = nn.ModuleList([Head(n_embd, n_embd // n_head) for _ in range(n_head)])
        self.proj = nn.Linear(n_embd, n_embd, bias=False)      # W_O

    def forward(self, x):
        out = [h(x) for h in self.heads]        # 4 个 (B, T, 16)
        out = torch.cat(out, dim=-1)            # (B, T, 64)，dim = -1
        return self.proj(out)                   # 融合回统一表示空间


# ======================================================================
# 3. 多头：四维张量一次算完（视频第四部分的工业写法）
# ======================================================================
class MultiHeadAttentionBatch(nn.Module):
    """一次 64→64 线性层算出合并的 Q/K/V，用 view + transpose 并行所有头。

    形状路径（视频里的核心）：
      x            (B, T, 64)
      q/k/v        (B, T, 64)          ← 三个 64→64 线性层
      view         (B, T, h, 16)       ← 头数是第四维
      transpose    (B, h, T, 16)       ← 让最后两维成为 5×16 的矩阵
      Q @ K^T      (B, h, T, T)        ← 一次批矩阵乘，16 张 5×5 一起算
      softmax @ V  (B, h, T, 16)
      transpose    (B, T, h, 16)
      contiguous + view  (B, T, 64)
      proj         (B, T, 64)
    """

    def __init__(self, n_embd=N_EMBD, n_head=N_HEAD):
        super().__init__()
        assert n_embd % n_head == 0
        self.n_head = n_head
        self.head_size = n_embd // n_head
        # 4 个头各自的 64×16 权重在列方向拼起来，就是一个 64×64 的大矩阵
        self.q_proj = nn.Linear(n_embd, n_embd, bias=False)
        self.k_proj = nn.Linear(n_embd, n_embd, bias=False)
        self.v_proj = nn.Linear(n_embd, n_embd, bias=False)
        self.proj = nn.Linear(n_embd, n_embd, bias=False)      # W_O
        self.register_buffer("tril", torch.tril(torch.ones(BLOCK, BLOCK)))

    def forward(self, x):
        B, T, C = x.shape
        h, d = self.n_head, self.head_size

        q = self.q_proj(x)                                   # (B, T, 64)
        k = self.k_proj(x)
        v = self.v_proj(x)

        # 第一步：把最后一维 64 拆成 4 × 16，三维变四维
        q = q.view(B, T, h, d)                               # (B, T, 4, 16)
        k = k.view(B, T, h, d)
        v = v.view(B, T, h, d)

        # 第二步：交换序列长度与头数，让最后两维变成单个头内部的 5 × 16
        q = q.transpose(1, 2)                                # (B, 4, T, 16)
        k = k.transpose(1, 2)
        v = v.transpose(1, 2)

        # 一次批矩阵乘：前面的 (B, h) 是批处理维度，最后两维参与矩阵乘
        att = q @ k.transpose(-2, -1)                        # (B, 4, T, T)
        att = att * (1.0 / math.sqrt(d))                     # 除以 sqrt(16) = 4
        att = att.masked_fill(self.tril[:T, :T] == 0, float("-inf"))
        att = F.softmax(att, dim=-1)
        out = att @ v                                        # (B, 4, T, 16)

        # 逆向：换回头在前，再合并最后两维
        out = out.transpose(1, 2)                            # (B, T, 4, 16)
        out = out.contiguous()          # 转置不动内存，必须重新排一次才能 view
        out = out.view(B, T, C)                              # (B, T, 64)
        return self.proj(out)


# ======================================================================
# 验证
# ======================================================================
def count_params(m):
    return sum(p.numel() for p in m.parameters())


def main():
    torch.manual_seed(1337)
    x = torch.randn(BATCH, BLOCK, N_EMBD)

    single = CausalSelfAttention().eval()
    multi = MultiHeadAttention().eval()
    batch = MultiHeadAttentionBatch().eval()

    with torch.no_grad():
        y1, y2, y3 = single(x), multi(x), batch(x)

    print("输入 x:", tuple(x.shape), "（4 条样本 × 5 个 token × 64 维）")
    print("单头输出:", tuple(y1.shape))
    print("多头（ModuleList）输出:", tuple(y2.shape))
    print("多头（四维张量）输出:", tuple(y3.shape))
    print()

    # ---- 参数账（对应视频第三部分结尾）----
    qkv_single = single.qkv.weight.numel()
    qkv_multi = sum(h.query.weight.numel() + h.key.weight.numel() + h.value.weight.numel()
                    for h in multi.heads)
    print("参数账：")
    print("  单头 Q/K/V   %6d" % qkv_single)
    print("  4 头 Q/K/V   %6d   （与单头完全相等）" % qkv_multi)
    print("  输出投影 W_O %6d   （多头真正新增的部分）" % multi.proj.weight.numel())
    print()

    # ---- 两种多头写法等价性：拼权重后比较输出 ----
    with torch.no_grad():
        for name in ("query", "key", "value"):
            W = torch.cat([getattr(h, name).weight for h in multi.heads], dim=0)  # (64, 64)
            getattr(batch, name.replace("query", "q").replace("key", "k").replace("value", "v")
                    + "_proj").weight.copy_(W)
        batch.proj.weight.copy_(multi.proj.weight)
        ya = multi(x)
        yb = batch(x)
        err = (ya - yb).abs().max().item()
    print("两种写法输出形状:", tuple(ya.shape), tuple(yb.shape))
    print("最大绝对差: %.3e  → %s" % (err, "数学等价（仅浮点舍入）" if err < 1e-5 else "不一致！"))
    print()

    # ---- 因果掩码检查：第 t 个位置不能看到 t 之后 ----
    h0 = multi.heads[0]
    with torch.no_grad():
        q, k = h0.query(x), h0.key(x)
        raw = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(h0.key.out_features))
        masked = raw.masked_fill(h0.tril[:BLOCK, :BLOCK] == 0, float("-inf"))
        w = F.softmax(masked, dim=-1)
    upper = w.triu(diagonal=1)
    print("因果掩码：未来位置权重最大值 = %.1f（应为 0）" % upper.max().item())
    print("每一行权重和（应为 1）:", [round(float(v), 3) for v in w.sum(-1)[0]])


if __name__ == "__main__":
    main()
