#11. 工程题

T
lyrics_1
lyrics_2
...
lyrics_T

[二进制段: Header + Tokenizer + Song Names + Weights, 详见格式文档]
5
我仍然在，无人问津的阴雨霉湿之地，和着雨音，唱着没有听众的歌曲。
Xngsagh我仍然在无人问津的英语没454事之地 或者语音，唱着没有听众nxzh的歌曲。
夏夜空，寻觅着，色彩褪去
星点的回音汇成声浪强烈的力量，将心房不断叩响
我愿把记忆燃成灯火寻遍这星空，乘夜风飘飞挣脱万有引力的枷锁。冲破空间囚笼，跨越时间洪流。逃出虚妄和无奈编制的黑洞。

世末歌者
世末歌者
世末歌者
回音
寻遍星空

sample/
├── model.bin            纯模型数据 (文件读取方式使用)
├── input.bin            完整样例输入 (二进制段 + 文本段，标准输入方式使用)
└── output.txt           样例标准输出 (10行歌名)
example.cpp              C++ 样板程序 — 全部从 stdin 读取 (自包含)
example.py               Python 样板程序 — 全部从 stdin 读取 (自包含)
example_mix.cpp          C++ 样板程序 — 文件读权重 + stdin 读歌词 (自包含)
Attention is All You Need.pdf   原始论文参考

./solution < sample/input.bin
# 或在代码开头加:
# freopen("sample/input.bin", "rb", stdin);

Model loaded: 387 songs, hidden=192, 4 layers, vocab=11592
  song[0]="我的悲伤是水做的", song[386]="天魔策"
  tok_emb[5][0]=0.481048, song_queries[0][0]=0.149305
  2 test(s), first tokenized to 15 ids

token_ids [seq_len]
    │
    ▼
tok_emb[token_id] + pos_emb[position]     → x: [seq_len, 192]
    │
    ▼  ×4 层
┌─────────────────────────────────────┐
│  residual = x                       │
│  x = LayerNorm(x)                   │
│  x = MultiHeadSelfAttention(x)     │
│  x = residual + x                   │
│                                     │
│  residual = x                       │
│  x = LayerNorm(x)                   │
│  x = FFN(x)                         │
│  x = residual + x                   │
└─────────────────────────────────────┘
    │
    ▼
x = LayerNorm(x)                       → H: [seq_len, 192]  (Encoder 输出)
    │
    ▼
Cross-Attention 打分                    → scores: [num_songs]
    │
    ▼
argmax(scores)                          → 预测歌曲编号

x[t] = tok_emb[token_id[t]] + pos_emb[t]

softmax(x)[i] = exp(x[i]) / Σ_j exp(x[j])

m = max(x[0], x[1], ..., x[n-1])
e[i] = exp(x[i] - m)
softmax(x)[i] = e[i] / Σ_j e[j]

mean = (1/d) * Σ x[i]                        // i = 0..d-1
var  = (1/d) * Σ (x[i] - mean)²              // i = 0..d-1
out[i] = (x[i] - mean) / sqrt(var + 1e-5) * w[i] + b[i]

对 t = 0..seq_len-1:
    Q[t] = Wq @ x[t]        // Q[t] 是长度 192 的行向量
    K[t] = Wk @ x[t]
    V[t] = Wv @ x[t]

Q_h[t] = Q[t][h*48 .. h*48+47]
K_h[t] = K[t][h*48 .. h*48+47]
V_h[t] = V[t][h*48 .. h*48+47]

attn[i][j] = (Q_h[i] · K_h[j]) / sqrt(48)
attn[i]    = softmax(attn[i])          // 对 j 维 softmax
out_h[i]   = Σ_j  attn[i][j] * V_h[j]

concat[t] = [out_0[t], out_1[t], out_2[t], out_3[t]]   // 192 维
output[t] = Wo @ concat[t]

对 t = 0..seq_len-1:
    h[t] = ffn_w1 @ x[t] + ffn_b1       // h[t] 长度 768
    h[t] = GELU(h[t])
    y[t] = ffn_w2 @ h[t] + ffn_b2       // y[t] 长度 192

GELU(x) = 0.5 * x * (1 + tanh(0.7978845608 * (x + 0.044715 * x³)))

H[t] = LayerNorm(x[t], final_norm_w, final_norm_b)

// K、V 对所有歌曲共享，只需计算一次
对 t = 0..seq_len-1:
    K[t] = cross_Wk @ H[t]          // K[t] 长度 192
    V[t] = cross_Wv @ H[t]          // V[t] 长度 192

对每首歌 s = 0..386:
    Q = cross_Wq @ song_queries[s]   // Q 长度 192

    对 j = 0..seq_len-1:
        attn[j] = (Q · K[j]) / sqrt(192)    // 点积再除以 sqrt(192)
    attn = softmax(attn)

    z = Σ_j  attn[j] * V[j]         // z 长度 192

    score[s] = song_queries[s] · z   // 标量，注意这里用的是原始 song_queries[s]，非投影后的 Q

┌─────────────────────────────────────┐
│  Binary: Header + Tokenizer +       │
│          Song Names + Weights       │  ← 自描述长度, 解析后自动结束
├─────────────────────────────────────┤
│  Text:   T                          │  ← 测试数量
│          lyrics_1                   │  ← 每行一条歌词 (换行转义为 \n)
│          lyrics_2                   │
│          ...                        │
└─────────────────────────────────────┘

// ← 这里是 model.h 的全部内容（已粘贴）

int main() {
    Model m;
    m.load();                          // 从 stdin 读取二进制段
    int T = m.read_num_tests();        // 读取测试数量
    for (int i = 0; i < T; i++) {
        string lyrics = m.read_test(); // 读取一条歌词 (自动 unescape)
        vector<int> ids = m.tokenize(lyrics); // 歌词 → token id 序列
        int idx = predict(m, ids);     // 你的推理函数
        printf("%s\n", m.song_names[idx].c_str());
    }
}

# ← 这里是 model.py 的全部内容（已粘贴）

def predict(m, ids):
    # 你的推理函数
    return 0

m = Model()
m.load()
tests = m.read_tests()
for lyrics in tests:
    ids = m.tokenize(lyrics)
    idx = predict(m, ids)
    print(m.song_names[idx])

y = W @ x

即 y[i] = Σ_j  W[i][j] * x[j]

对 t = 0..seq_len-1:
    y[t][i] = Σ_j  W[i][j] * x[t][j]

输入 lyrics
    ↓ tokenize
token ids (len ≤ 512)
    ↓ Embedding (查表)
tok_emb[id] + pos_emb[pos]  → x[seq_len][192]
    ↓ 4× Pre-Norm Transformer Encoder Layer
    │   LayerNorm → 4-head Self-Attention (head_dim=48) → Residual
    │   LayerNorm → FFN (192→768, GELU, 768→192) → Residual
    ↓ Final LayerNorm
encoder output H[seq_len][192]
    ↓ Cross-Attention (单头)
    │   K[t] = cross_Wk @ H[t]
    │   V[t] = cross_Wv @ H[t]
    │   对每首歌 s:
    │     Q = cross_Wq @ song_queries[s]
    │     attn = softmax(Q·K^T / √192)
    │     z = Σ attn[j] * V[j]
    │     score[s] = song_queries[s] · z
    ↓ argmax(scores)
predicted song index → song_names[index]