Upload folder using huggingface_hub

deepseek_v4/visualize_attention_masks.py

@@ -184,9 +184,9 @@ def _render(
 SVG_CELL = 24
 SVG_GAP = 2
 SVG_PAD_LEFT = 120     # roomy enough for the longest row-label token ("morning") at 11pt
-SVG_PAD_TOP = 180      # title/shape/meta (60px) + C_w + pos + rotated tokens (~60px) + a touch.
+SVG_PAD_TOP = 200      # title (20) + shape (40) + meta (60) + section header (~80) + col idx + rotated tokens
 SVG_PAD_RIGHT = 48
-SVG_PAD_BOTTOM = 64
+SVG_PAD_BOTTOM = 56
 SVG_COLORS = {
     # Dark-mode palette: black background, light text.
     "background": "#0b1220",    # near-black with a hint of blue
@@ -225,11 +225,12 @@ def _render_svg(mask_2d: torch.Tensor, title: str, sliding_kv: int, meta: dict |
     n_compr = n_kv - sliding_kv
     m = (meta or {}).get("compress_rate") or 1
     stride = SVG_CELL + SVG_GAP
-    compr_block_w = m * SVG_CELL + (m - 1) * SVG_GAP
 
-    # Per-column x positions and widths. Sliding cells: 1×cell. Compressor entries:
-    # `m`×cell wide each, with a small gap between sections.
-    section_gap = SVG_GAP * 4
+    # All cells (sliding + compressor) are the same `SVG_CELL` width — a single KV slot
+    # is a single KV slot regardless of which cache produced it. The compressor section
+    # is shifted right by `section_gap` so the `cat([sliding_mask, block_bias])` boundary
+    # reads clearly.
+    section_gap = stride * 2
     col_x: list[float] = []
     col_w: list[float] = []
     cursor = float(SVG_PAD_LEFT)
@@ -241,12 +242,21 @@ def _render_svg(mask_2d: torch.Tensor, title: str, sliding_kv: int, meta: dict |
         cursor += section_gap
     for _w in range(n_compr):
         col_x.append(cursor)
-        col_w.append(compr_block_w)
-        cursor += compr_block_w + stride
+        col_w.append(SVG_CELL)
+        cursor += stride
     grid_w = cursor - SVG_PAD_LEFT - stride
     grid_h = n_q * stride - SVG_GAP
+
+    # Footer legend: one line per compressed entry mapping it to its source tokens.
+    legend_lines = []
+    for w_idx in range(n_compr):
+        a, b = w_idx * m, (w_idx + 1) * m - 1
+        toks = [SVG_TOKENS[p] if p < len(SVG_TOKENS) else f"t{p}" for p in range(a, b + 1)]
+        legend_lines.append(f"C{w_idx}  =  compress( {',  '.join(toks)} )")
+    footer_h = (len(legend_lines) * 18 + 32) if legend_lines else 0
+
     w = SVG_PAD_LEFT + grid_w + SVG_PAD_RIGHT
-    h = SVG_PAD_TOP + grid_h + SVG_PAD_BOTTOM
+    h = SVG_PAD_TOP + grid_h + SVG_PAD_BOTTOM + footer_h
 
     subtitle = _meta_subtitle(meta)
     # Explicit `width` / `height` (matching viewBox) so renderers don't fall back to the
@@ -291,40 +301,42 @@ def _render_svg(mask_2d: torch.Tensor, title: str, sliding_kv: int, meta: dict |
             f'transform="rotate(-90 {cx:.1f} {token_baseline_y})" '
             f'fill="{SVG_COLORS["text"]}" font-size="12" font-style="italic">{tok}</text>'
         )
+    # `C_w` label sits on the same row as the sliding-section indices — the compressor
+    # cell looks like any other KV slot, with its `C_w` identifier centered above it
+    # in the column-index band. The actual source-tokens-that-got-compressed mapping
+    # lives in the footer legend so the body of the diagram stays clean.
     for w_idx in range(n_compr):
         j = sliding_kv + w_idx
         cx = col_x[j] + col_w[j] / 2
-        block_x = col_x[j]
-        a, b = w_idx * m, (w_idx + 1) * m - 1
-        # `C_w` + `pos a–b` sit on the same row as the sliding-section indices, hugging
-        # the top of the rotated-token area — same vertical band as the column ticks.
         elems.append(
-            f'  <text x="{cx:.1f}" y="{idx_y - 14}" text-anchor="middle" '
-            f'fill="{SVG_COLORS["visible"]}" font-size="13" font-weight="700">C{w_idx}</text>'
+            f'  <text x="{cx:.1f}" y="{idx_y}" text-anchor="middle" '
+            f'fill="{SVG_COLORS["visible"]}" font-size="11" font-weight="700">C{w_idx}</text>'
         )
+
+    # Section headers + `cat` indicator above the column-index band. The dashed
+    # separator line marks the `cat([sliding_mask, block_bias], dim=-1)` join.
+    if sliding_kv > 0:
+        sliding_mid_x = (col_x[0] + col_x[sliding_kv - 1] + col_w[sliding_kv - 1]) / 2
         elems.append(
-            f'  <text x="{cx:.1f}" y="{idx_y}" text-anchor="middle" '
-            f'fill="{SVG_COLORS["muted"]}" font-size="10">pos {a}–{b}</text>'
+            f'  <text x="{sliding_mid_x:.1f}" y="{idx_y - 32}" text-anchor="middle" '
+            f'fill="{SVG_COLORS["text"]}" font-size="12" font-weight="600">Sliding K=V cache</text>'
+        )
+    if n_compr > 0:
+        compr_mid_x = (col_x[sliding_kv] + col_x[-1] + col_w[-1]) / 2
+        elems.append(
+            f'  <text x="{compr_mid_x:.1f}" y="{idx_y - 32}" text-anchor="middle" '
+            f'fill="{SVG_COLORS["text"]}" font-size="12" font-weight="600">Compressed cache</text>'
+        )
+        # `cat` operator centered in the section gap between the two sections.
+        cat_x = (col_x[sliding_kv - 1] + col_w[sliding_kv - 1] + col_x[sliding_kv]) / 2
+        elems.append(
+            f'  <text x="{cat_x:.1f}" y="{idx_y - 32}" text-anchor="middle" '
+            f'fill="{SVG_COLORS["muted"]}" font-size="14" font-weight="700">⊕</text>'
+        )
+        elems.append(
+            f'  <text x="{cat_x:.1f}" y="{idx_y - 18}" text-anchor="middle" '
+            f'fill="{SVG_COLORS["muted"]}" font-size="9">cat dim=-1</text>'
         )
-        # One rotated label per source position, dashed vertical separators between
-        # sub-cells inside the block (only as tall as the rotated-token area, not the
-        # whole gutter — they're a hint that the wide green block bundles m positions).
-        for sub_i in range(m):
-            pos = a + sub_i
-            sub_cx = block_x + sub_i * stride + SVG_CELL / 2
-            tok = SVG_TOKENS[pos] if pos < len(SVG_TOKENS) else f"t{pos}"
-            elems.append(
-                f'  <text x="{sub_cx:.1f}" y="{token_baseline_y}" text-anchor="start" '
-                f'transform="rotate(-90 {sub_cx:.1f} {token_baseline_y})" '
-                f'fill="{SVG_COLORS["text"]}" font-size="12" font-style="italic">{tok}</text>'
-            )
-            if sub_i > 0:
-                sep_x = block_x + sub_i * stride - SVG_GAP / 2
-                elems.append(
-                    f'  <line x1="{sep_x:.1f}" y1="{token_top_y}" '
-                    f'x2="{sep_x:.1f}" y2="{SVG_PAD_TOP}" '
-                    f'stroke="{SVG_COLORS["separator"]}" stroke-width="0.7" stroke-dasharray="3 3" />'
-                )
 
     # Row labels: query index (small, muted) + token (italic, dark) on the left.
     # `SVG_PAD_LEFT` is sized to fit the longest token in the static word list.
@@ -396,6 +408,22 @@ def _render_svg(mask_2d: torch.Tensor, title: str, sliding_kv: int, meta: dict |
         )
         x_cursor += 20 + len(label) * 6.5 + 24
 
+    # Footer: `C_w = compress(token, token, …)` lines, one per compressed entry. Says
+    # explicitly which source tokens each compressed-cache slot summarises — replaces
+    # the per-cell rotated-token annotations we used to render above each C_w block
+    # when the compressor section had wide cells.
+    if legend_lines:
+        footer_y = legend_y + 24
+        elems.append(
+            f'  <text x="{SVG_PAD_LEFT}" y="{footer_y}" '
+            f'fill="{SVG_COLORS["muted"]}" font-size="11" font-weight="600">Compressed cache contents</text>'
+        )
+        for line_idx, line in enumerate(legend_lines):
+            elems.append(
+                f'  <text x="{SVG_PAD_LEFT}" y="{footer_y + 18 + line_idx * 18}" '
+                f'fill="{SVG_COLORS["text"]}" font-size="11">{line}</text>'
+            )
+
     elems.append("</svg>")
     return "\n".join(elems)