model-unfolder 0.2.6__tar.gz → 0.2.7__tar.gz

{model_unfolder-0.2.6 → model_unfolder-0.2.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model-unfolder
-Version: 0.2.6
+Version: 0.2.7
 Summary: Unfold any HuggingFace transformer into an interactive architecture diagram, inline in Jupyter.
 Author: model-unfolder contributors
 License: Apache-2.0

{model_unfolder-0.2.6 → model_unfolder-0.2.7}/model_unfolder/adapters/transformer/blocks/attention.py

@@ -26,6 +26,18 @@ def _sdpa_child_blocks(attention: AttentionSpec, hidden_size: int) -> list[dict]
     q_out = _fmt(num_heads * head_dim) if (num_heads and head_dim) else hidden
     kv_out = _fmt(num_kv_heads * head_dim) if (num_kv_heads and head_dim) else hidden
     d_k = _fmt(head_dim) if head_dim else "d_k"
+    if attention.kind in {"mha", "gqa", "mqa"}:
+        return _sdpa_detailed_child_blocks(
+            attention.kind,
+            hidden,
+            q_out,
+            kv_out,
+            num_heads,
+            num_kv_heads,
+            d_k,
+            q_per_group,
+        )
+
     attention_title, attention_desc = _sdpa_operation_meta(attention, num_heads, num_kv_heads, d_k, q_per_group)
     return [
         {
@@ -56,6 +68,77 @@ def _sdpa_child_blocks(attention: AttentionSpec, hidden_size: int) -> list[dict]
     ]
 
 
+def _sdpa_detailed_child_blocks(
+    kind: str,
+    hidden: str,
+    q_out: str,
+    kv_out: str,
+    num_heads: int,
+    num_kv_heads: int,
+    d_k: str,
+    q_per_group: int | None,
+) -> list[dict]:
+    kv_label = "1 shared K/V head" if kind == "mqa" else f"{num_kv_heads} KV-heads"
+    scaled_title = "Scaled attention scores"
+    scaled_desc = "Per head: QK^T / sqrt(dim); dot-product scores scaled for numerical stability"
+    if kind == "gqa":
+        scaled_title = "Grouped scaled dot-product attention"
+        group = f"; each KV head serves {q_per_group} query heads" if q_per_group else ""
+        scaled_desc = (
+            f"Grouped SDPA scores: {num_heads} query heads attend through "
+            f"{num_kv_heads} shared K/V heads{group}; scores use QK^T / sqrt(dim)"
+        )
+    elif kind == "mqa":
+        scaled_title = "Multi-query scaled dot-product attention"
+        scaled_desc = (
+            f"Multi-Query SDPA scores: {num_heads} query heads share one K/V stream; "
+            "scores use QK^T / sqrt(dim)"
+        )
+
+    return [
+        {
+            "id": "q_proj",
+            "title": "Query projection",
+            "description": f"Linear; {hidden} -> {q_out}  ({num_heads} heads x {d_k} dims)",
+        },
+        {
+            "id": "k_proj",
+            "title": "Key projection",
+            "description": f"Linear; {hidden} -> {kv_out}  ({kv_label} x {d_k} dims)",
+        },
+        {
+            "id": "v_proj",
+            "title": "Value projection",
+            "description": f"Linear; {hidden} -> {kv_out}  ({kv_label} x {d_k} dims)",
+        },
+        {
+            "id": "scaled_scores",
+            "title": scaled_title,
+            "description": scaled_desc,
+        },
+        {
+            "id": "attn_softmax",
+            "title": "Softmax weights",
+            "description": "Normalize each query row into attention weights over source tokens",
+        },
+        {
+            "id": "attn_apply_v",
+            "title": "Apply values",
+            "description": "Multiply attention weights by V to produce one context vector per head",
+        },
+        {
+            "id": "concat_heads",
+            "title": "Concatenate heads",
+            "description": f"Stack all {num_heads} per-head context vectors back into width {q_out}",
+        },
+        {
+            "id": "o_proj",
+            "title": "Output projection",
+            "description": f"Linear; {q_out} -> {hidden}  (mixes information across heads)",
+        },
+    ]
+
+
 def _sdpa_operation_meta(
     attention: AttentionSpec,
     num_heads: int,
@@ -102,40 +185,138 @@ def _mla_child_blocks(attention: AttentionSpec, hidden_size: int) -> list[dict]:
     num_heads = attention.num_heads or 0
     head_dim = attention.head_dim or 0
     q_out = _fmt(num_heads * head_dim) if (num_heads and head_dim) else hidden
-    return [
+    query_children = [
         {
             "id": "mla_q",
             "label": "Q projection",
             "title": "Query projection",
             "description": (
-                f"Projects hidden states into query heads through LoRA rank {q_rank}"
+                f"Projects hidden states into query latent space through LoRA rank {q_rank}"
                 if attention.q_lora_rank
-                else f"Q projection; {hidden} -> {q_out}"
+                else f"Projects hidden states directly into query heads; {hidden} -> {q_out}"
             ),
         },
+        {
+            "id": "mla_q_nope",
+            "label": "Q noPE",
+            "title": "Query content slice",
+            "description": "Query content component that does not receive rotary position encoding",
+        },
+        {
+            "id": "mla_q_rope",
+            "label": "Q RoPE",
+            "title": "Query positional slice",
+            "description": f"Query positional component prepared for rotary position encoding; dim {rope}",
+        },
+        {
+            "id": "mla_q_rope_apply",
+            "label": "Apply RoPE",
+            "title": "Apply RoPE to query",
+            "description": "Applies rotary position encoding to the query positional slice",
+        },
+        {
+            "id": "mla_q_concat",
+            "label": "Q concat",
+            "title": "Final MLA query",
+            "description": "Concatenates Q noPE with RoPE-encoded Q RoPE before score computation",
+        },
+    ]
+    kv_children = [
         {
             "id": "mla_kv_down",
             "label": "KV compress",
             "title": "K/V latent compression",
-            "description": f"Compresses the token state into a shared latent K/V vector; {hidden} -> rank {kv_rank}",
+            "description": f"Compresses the token state into the shared latent K/V cache; {hidden} -> rank {kv_rank}",
+        },
+        {
+            "id": "mla_cache",
+            "label": "latent cache c_t",
+            "title": "Stored latent cache",
+            "description": f"Compressed K/V latent stored in the cache instead of full K and V heads; rank {kv_rank}",
         },
         {
             "id": "mla_kv_up",
             "label": "KV expand",
             "title": "K/V head expansion",
-            "description": f"Expands the latent K/V vector into per-head key/value content for {num_heads} query heads",
+            "description": f"Expands cached latent c_t into K noPE content and V values for {num_heads} query heads",
+        },
+        {
+            "id": "mla_k_nope",
+            "label": "K noPE",
+            "title": "Latent key content",
+            "description": "Key content expanded from the compressed K/V latent; concatenated with the RoPE key before scoring",
+        },
+        {
+            "id": "mla_k_rope",
+            "label": "K RoPE",
+            "title": "Key positional slice",
+            "description": f"Key positional component produced alongside the latent cache; dim {rope}",
+        },
+        {
+            "id": "mla_k_rope_apply",
+            "label": "Apply RoPE",
+            "title": "Apply RoPE to key",
+            "description": "Applies rotary position encoding to the key positional slice",
+        },
+        {
+            "id": "mla_k_merge",
+            "label": "K concat",
+            "title": "Composed MLA key",
+            "description": "Concatenates K noPE with the RoPE key side-channel before QK^T score computation",
+        },
+        {
+            "id": "mla_v",
+            "label": "V values",
+            "title": "Latent value heads",
+            "description": "Value heads expanded from the compressed K/V latent; consumed after softmax",
+        },
+    ]
+    return [
+        {
+            "id": "mla_query_path",
+            "label": "Query path",
+            "title": "MLA query path",
+            "description": (
+                "Builds Q by projecting the hidden state, splitting content and positional slices, "
+                "applying RoPE to the positional slice, then concatenating them"
+            ),
+            "detail_view": "mla_query_path",
+            "children": query_children,
+        },
+        {
+            "id": "mla_kv_path",
+            "label": "KV cache path",
+            "title": "MLA K/V cache path",
+            "description": (
+                f"Compresses hidden state into rank {kv_rank} latent cache, expands K/V content, "
+                "and combines K noPE with a RoPE key side-channel"
+            ),
+            "detail_view": "mla_kv_cache_path",
+            "children": kv_children,
+        },
+        {
+            "id": "scaled_scores",
+            "label": "Latent scores",
+            "title": "Multi-Head Latent scores",
+            "description": "Q attends to expanded latent K plus the RoPE key side-channel; scores use QK^T / sqrt(dim)",
+        },
+        {
+            "id": "attn_softmax",
+            "label": "Softmax",
+            "title": "Softmax weights",
+            "description": "Normalize latent attention scores over source positions",
         },
         {
-            "id": "mla_rope",
-            "label": "RoPE key",
-            "title": "Rotary key side-channel",
-            "description": f"Separate positional key slice used with RoPE; dim {rope}",
+            "id": "attn_apply_v",
+            "label": "Apply V",
+            "title": "Apply latent values",
+            "description": "Multiply softmax weights by V expanded from the compressed K/V latent",
         },
         {
-            "id": "mla_attn",
-            "label": "Latent attention",
-            "title": "Multi-head latent attention",
-            "description": "Attention over decompressed latent K/V plus the RoPE side channel",
+            "id": "concat_heads",
+            "label": "Concat heads",
+            "title": "Concatenate latent heads",
+            "description": f"Stack all {num_heads} context heads back into width {q_out}",
         },
         {
             "id": "o_proj",

{model_unfolder-0.2.6 → model_unfolder-0.2.7}/model_unfolder/renderers/html/block_views/__init__.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 from .attention import attention_card, attention_card_css, build_attention_view
+from .attention_types import build_mla_kv_cache_view, build_mla_query_path_view
 from .feed_forward import build_dense_ffn_view, build_ffn_view
 from .mixture_of_experts import build_moe_expert_view, build_moe_view
 from .per_layer_embedding import build_per_layer_embedding_view
@@ -28,6 +29,10 @@ def block_detail_svg(ir: dict, info: dict, mount_id: str, block: dict) -> str |
 
 def sub_block_detail_svg(ir: dict, info: dict, mount_id: str, child: dict) -> str | None:
     """Return a rich SVG for a clicked node inside a detail view."""
+    if child.get("detail_view") == "mla_query_path":
+        return build_mla_query_path_view(ir, info, mount_id, child)
+    if child.get("detail_view") == "mla_kv_cache_path":
+        return build_mla_kv_cache_view(ir, info, mount_id, child)
     if child.get("detail_view") == "moe_expert":
         return build_moe_expert_view(ir, info, mount_id, child)
     return None

{model_unfolder-0.2.6 → model_unfolder-0.2.7}/model_unfolder/renderers/html/block_views/attention_types/__init__.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 
 from .grouped_query import build as build_gqa_attention_view
 from .latent import build as build_mla_attention_view
+from .latent import build_kv_cache_view as build_mla_kv_cache_view
+from .latent import build_query_path_view as build_mla_query_path_view
 from .linear import build as build_linear_attention_view
 from .multi_head import build as build_sdpa_attention_view
 from .multi_query import build as build_mqa_attention_view
@@ -14,6 +16,8 @@ __all__ = [
     "build_gqa_attention_view",
     "build_linear_attention_view",
     "build_mla_attention_view",
+    "build_mla_kv_cache_view",
+    "build_mla_query_path_view",
     "build_mqa_attention_view",
     "build_recurrent_view",
     "build_rwkv_view",

{model_unfolder-0.2.6 → model_unfolder-0.2.7}/model_unfolder/renderers/html/block_views/attention_types/common.py

@@ -11,7 +11,7 @@ from ...svg import (
     _svg_text,
     _v_line,
 )
-from ...theme import C, FONT_MONO, GAP
+from ...theme import C, FONT_HEAD, FONT_MONO, GAP
 from ...utils import _fmt_int
 
 
@@ -38,6 +38,9 @@ def gqa_grouping_panel(
     num_kv_heads: int,
     q_per_group: int | None,
 ) -> dict:
+    if w <= 300:
+        return _gqa_compact_legend(parts, x, y, w, h, num_heads, num_kv_heads, q_per_group)
+
     parts.append(_svg_tag("rect", {
         "x": x,
         "y": y,
@@ -81,6 +84,93 @@ def gqa_grouping_panel(
     }
 
 
+def _gqa_compact_legend(
+    parts: list[str],
+    x: float,
+    y: float,
+    w: float,
+    h: float,
+    num_heads: int,
+    num_kv_heads: int,
+    q_per_group: int | None,
+) -> dict:
+    parts.append(_svg_tag("rect", {
+        "x": x,
+        "y": y,
+        "width": w,
+        "height": h,
+        "rx": 14,
+        "ry": 14,
+        "fill": C["bg_card"],
+        "stroke": C["border"],
+        "stroke-width": 0.7,
+    }))
+    parts.append(_svg_text(
+        x + 18,
+        y + 24,
+        "KV sharing pattern",
+        {
+            "fill": C["text"],
+            "font-family": FONT_MONO,
+            "font-size": 10,
+            "font-weight": 700,
+            "letter-spacing": "0.08em",
+        },
+    ))
+    subtitle = (
+        f"{q_per_group} Q heads per KV"
+        if q_per_group
+        else f"{num_heads} Q / {num_kv_heads} KV"
+    )
+    parts.append(_svg_text(
+        x + 18,
+        y + 42,
+        subtitle,
+        {"fill": C["muted"], "font-family": FONT_MONO, "font-size": 9},
+    ))
+
+    card_y = y + 58
+    card_h = 34
+    gap = 7
+    card_w = w - 36
+    for i, (top, bottom) in enumerate(_gqa_card_specs(num_heads, num_kv_heads, q_per_group)):
+        cy = card_y + i * (card_h + gap)
+        parts.append(_svg_tag("rect", {
+            "x": x + 18,
+            "y": cy,
+            "width": card_w,
+            "height": card_h,
+            "rx": 9,
+            "ry": 9,
+            "fill": C["badge_bg"],
+            "stroke": C["border"],
+            "stroke-width": 0.7,
+        }))
+        parts.append(_svg_text(
+            x + 36,
+            cy + 14,
+            top,
+            {"fill": C["text"], "font-family": FONT_MONO, "font-size": 10, "font-weight": 700},
+        ))
+        parts.append(_svg_text(
+            x + 36,
+            cy + 28,
+            bottom,
+            {"fill": C["muted"], "font-family": FONT_MONO, "font-size": 8.5},
+        ))
+
+    return {
+        "left": x,
+        "right": x + w,
+        "top": y,
+        "bottom": y + h,
+        "cx": x + w / 2,
+        "cy": y + h / 2,
+        "w": w,
+        "h": h,
+    }
+
+
 def mqa_shared_kv_node(parts: list[str], x: float, y: float, w: float, h: float, num_heads: int) -> dict:
     parts.append(_svg_tag("rect", {
         "x": x,
@@ -308,3 +398,121 @@ def attn_dim_label(parts: list[str], x: float, y: float, text: str, *, anchor: s
             "font-size": 10,
         },
     ))
+
+
+def sdpa_fraction_block(
+    parts: list[str],
+    info: dict,
+    shadow_id: str,
+    node_id: str,
+    x: float,
+    y: float,
+    w: float,
+    h: float,
+    *,
+    numerator: str = "Q K^T",
+    denominator: str = "sqrt(dim)",
+) -> dict:
+    """Green formula block for the scaled score step in SDPA-style attention."""
+    children = [
+        _svg_tag("rect", {
+            "x": x,
+            "y": y,
+            "width": w,
+            "height": h,
+            "rx": 11,
+            "ry": 11,
+            "fill": C["block"],
+            "stroke": C["block_alt"],
+            "stroke-width": 0.6,
+            "filter": f"url(#{shadow_id})",
+        }),
+        _svg_text(
+            x + w / 2,
+            y + h * 0.32,
+            numerator,
+            {
+                "text-anchor": "middle",
+                "dominant-baseline": "central",
+                "fill": C["text_block"],
+                "font-family": FONT_HEAD,
+                "font-size": 22,
+                "pointer-events": "none",
+            },
+        ),
+        _svg_tag("line", {
+            "x1": x + 72,
+            "y1": y + h * 0.52,
+            "x2": x + w - 72,
+            "y2": y + h * 0.52,
+            "stroke": C["text_block"],
+            "stroke-width": 1.7,
+            "stroke-linecap": "round",
+            "pointer-events": "none",
+        }),
+        _svg_text(
+            x + w / 2,
+            y + h * 0.73,
+            denominator,
+            {
+                "text-anchor": "middle",
+                "dominant-baseline": "central",
+                "fill": C["text_block"],
+                "font-family": FONT_HEAD,
+                "font-size": 19,
+                "pointer-events": "none",
+            },
+        ),
+    ]
+    parts.append(_svg_tag("g", {"class": "uf-node", "data-id": node_id}, "".join(children)))
+    return {"left": x, "right": x + w, "top": y, "bottom": y + h, "cx": x + w / 2, "cy": y + h / 2, "w": w, "h": h}
+
+
+def sdpa_dot_operator(parts: list[str], info: dict, shadow_id: str, node_id: str, cx: float, cy: float) -> dict:
+    """Small green dot-product operator used for attention weights × V."""
+    r = 16
+    children = [
+        _svg_tag("circle", {
+            "cx": cx,
+            "cy": cy,
+            "r": r,
+            "fill": C["block"],
+            "stroke": C["block_alt"],
+            "stroke-width": 0.6,
+            "filter": f"url(#{shadow_id})",
+        }),
+        _svg_tag("circle", {
+            "cx": cx,
+            "cy": cy,
+            "r": 5,
+            "fill": "none",
+            "stroke": C["text_block"],
+            "stroke-width": 2,
+            "pointer-events": "none",
+        }),
+    ]
+    parts.append(_svg_tag("g", {"class": "uf-node", "data-id": node_id}, "".join(children)))
+    return {"left": cx - r, "right": cx + r, "top": cy - r, "bottom": cy + r, "cx": cx, "cy": cy, "r": r}
+
+
+def input_to_block(x1: float, y1: float, x2: float, y2: float, arrow_id: str, *, lane_offset: float = 26) -> str:
+    """Route an upward input into the lower edge of a block without grazing it."""
+    lane_y = y2 + lane_offset
+    r = 10
+    d = (
+        f"M {x1:g} {y1:g} "
+        f"L {x1:g} {lane_y + r:g} "
+        f"Q {x1:g} {lane_y:g} {x1 + r:g} {lane_y:g} "
+        f"L {x2 - r:g} {lane_y:g} "
+        f"Q {x2:g} {lane_y:g} {x2:g} {lane_y - r:g} "
+        f"L {x2:g} {y2:g}"
+    )
+    return _svg_tag("path", {
+        "d": d,
+        "fill": "none",
+        "stroke": C["arrow"],
+        "stroke-width": 1.6,
+        "stroke-linecap": "round",
+        "stroke-linejoin": "round",
+        "marker-end": f"url(#{arrow_id})",
+    })

{model_unfolder-0.2.6 → model_unfolder-0.2.7}/model_unfolder/renderers/html/block_views/attention_types/grouped_query.py

@@ -5,6 +5,7 @@ from ...svg import (
     _branch_dot,
     _defs,
     _elbow_hv,
+    _elbow_vh,
     _ids,
     _rect_block,
     _region_rect,
@@ -17,16 +18,19 @@ from ...theme import C, GAP
 from ...utils import _fmt_int
 from .common import (
     gqa_grouping_panel,
+    input_to_block,
     kv_cache_badge,
     output_stem,
     placed_figure,
     queries_per_kv_group,
+    sdpa_dot_operator,
+    sdpa_fraction_block,
 )
 
 
 def build(ir: dict, info: dict, mount_id: str) -> str:
     """Detail view for grouped-query attention."""
-    w, h = 720, 730
+    w, h = 820, 880
     arrow_id, shadow_id = _ids(mount_id, "gqa-attn")
     parts = [_defs(arrow_id, shadow_id)]
     parts.append(_region_rect(40, 30, w - 80, h - 60, C["bg_outer"]))
@@ -42,31 +46,38 @@ def build(ir: dict, info: dict, mount_id: str) -> str:
     q_per_group = queries_per_kv_group(num_heads, num_kv_heads)
 
     cx = w / 2
-    o_proj = _rect_block(body, info, shadow_id, "o_proj", cx - 92, 78, 184, 50, "Linear (out)")
-    sdpa = _rect_block(
+    o_proj = _rect_block(body, info, shadow_id, "o_proj", cx - 100, 72, 200, 52, "Linear (out)")
+    concat = _rect_block(
         body,
         info,
         shadow_id,
-        "qkv_dot",
-        126,
-        165,
-        468,
-        58,
-        ["Grouped SDPA", f"{num_heads} Q / {num_kv_heads} KV heads  ·  d_k = {d_k}"],
-        font_size=15,
+        "concat_heads",
+        cx - 112,
+        164,
+        224,
+        54,
+        ["Concat heads", f"{num_heads} x {d_k}" if num_heads else "per head"],
+        font_size=16,
     )
+    value_dot = sdpa_dot_operator(body, info, shadow_id, "attn_apply_v", cx, 276)
+    softmax = _rect_block(body, info, shadow_id, "attn_softmax", cx - 96, 344, 192, 52, "Softmax")
+    scaled_scores = sdpa_fraction_block(body, info, shadow_id, "scaled_scores", cx - 140, 452, 280, 82)
+    gqa_grouping_panel(body, 64, 92, 220, 218, num_heads, num_kv_heads, q_per_group)
 
-    panel = gqa_grouping_panel(body, 76, 280, 568, 114, num_heads, num_kv_heads, q_per_group)
+    body.append(_v_line(scaled_scores, softmax, arrow_id))
+    body.append(_v_line(softmax, value_dot, arrow_id))
+    body.append(_v_line(value_dot, concat, arrow_id))
+    body.append(_v_line(concat, o_proj, arrow_id))
 
-    proj_w, proj_h, proj_y = 168, 50, 474
-    q_proj = _rect_block(body, info, shadow_id, "q_proj", 70, proj_y, proj_w, proj_h, ["Linear (Q)", f"{num_heads} heads"], font_size=15)
+    proj_w, proj_h, proj_y = 185, 52, 704
+    q_proj = _rect_block(body, info, shadow_id, "q_proj", 78, proj_y, proj_w, proj_h, ["Linear (Q)", f"{num_heads} heads"], font_size=15)
     kv_head_label = f"{num_kv_heads} head" if num_kv_heads == 1 else f"{num_kv_heads} heads"
-    k_proj = _rect_block(body, info, shadow_id, "k_proj", 276, proj_y, proj_w, proj_h, ["Linear (K)", kv_head_label], font_size=15)
-    v_proj = _rect_block(body, info, shadow_id, "v_proj", 482, proj_y, proj_w, proj_h, ["Linear (V)", kv_head_label], font_size=15)
+    k_proj = _rect_block(body, info, shadow_id, "k_proj", cx - proj_w / 2, proj_y, proj_w, proj_h, ["Linear (K)", kv_head_label], font_size=15)
+    v_proj = _rect_block(body, info, shadow_id, "v_proj", w - 78 - proj_w, proj_y, proj_w, proj_h, ["Linear (V)", kv_head_label], font_size=15)
 
-    branch_x, branch_y = cx, 582
+    branch_x, branch_y = cx, 792
     body.append(_svg_tag("line", {
-        "x1": branch_x, "y1": branch_y + 36, "x2": branch_x, "y2": branch_y,
+        "x1": branch_x, "y1": branch_y + 34, "x2": branch_x, "y2": branch_y,
         "stroke": C["arrow"], "stroke-width": 1.6, "stroke-linecap": "round",
         "fill": "none",
     }))
@@ -75,12 +86,9 @@ def build(ir: dict, info: dict, mount_id: str) -> str:
     body.append(_elbow_hv(branch_x, branch_y, v_proj["cx"], v_proj["bottom"] + GAP, arrow_id))
     body.append(_branch_dot(branch_x, branch_y))
 
-    panel_entry_y = panel["bottom"] + GAP
-    body.append(_v_seg(q_proj["cx"], q_proj["top"], panel_entry_y, arrow_id))
-    body.append(_v_seg(k_proj["cx"], k_proj["top"], panel_entry_y, arrow_id))
-    body.append(_v_seg(v_proj["cx"], v_proj["top"], panel_entry_y, arrow_id))
-    body.append(_v_line(panel, sdpa, arrow_id))
-    body.append(_v_line(sdpa, o_proj, arrow_id))
+    body.append(input_to_block(q_proj["cx"], q_proj["top"], scaled_scores["left"] + 92, scaled_scores["bottom"], arrow_id))
+    body.append(_v_seg(k_proj["cx"], k_proj["top"], scaled_scores["bottom"], arrow_id))
+    body.append(_elbow_vh(v_proj["cx"], v_proj["top"], value_dot["right"] + GAP, value_dot["cy"], arrow_id))
     output_stem(body, cx, o_proj, arrow_id, hidden, show_label=False)
 
     if q_per_group and q_per_group > 1: