maze_probe_test.py

import os
import argparse
import pickle
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import networkx as nx
import random
import matplotlib.pyplot as plt
from tqdm import tqdm
from torch.nn.utils.rnn import pad_sequence

# Import project modules
from model.transformer import GPTConfig, GPT
from cli_utils import parse_count, format_count


def parse_args():
    parser = argparse.ArgumentParser(description='Linear Probe Test: Node Representation Analysis.')

    # --- Model & Data Configuration ---
    parser.add_argument('--ckpt_iter', type=int, default=10000,
                        help='Checkpoint iteration to load')
    parser.add_argument('--config', type=str, default='12_6_384',
                        help='Model configuration string (e.g., 1_1_120)')
    parser.add_argument('--device', type=str, default='cuda:0',
                        help='Device to use (e.g., cuda:0, cpu)')
    parser.add_argument('--num_nodes', type=int, default=100,
                        help='Number of nodes in the maze grid')
    parser.add_argument('--num_of_paths', type=int, default=20,
                        help='Number of paths used in single-task data naming')
    parser.add_argument('--multitasks', action=argparse.BooleanOptionalAction, default=True,
                        help='Use multitask data logic (default: True)')
    parser.add_argument('--num_train_dataset', type=parse_count, default='10M',
                        help='Number of multitask training entries (supports K/M/B)')
    parser.add_argument('--num_test_dataset', type=parse_count, default=10000,
                        help='Number of multitask test entries (supports K/M/B)')
    parser.add_argument('--tasks', type=str, default='C1',
                        help='Task specification for filename resolution (e.g., A1, A1E1)')
    parser.add_argument('--CL', action=argparse.BooleanOptionalAction, default=False,
                        help='Task C turn-label mode flag')
    parser.add_argument('--path_type', type=str, default='RWs', choices=['RWc', 'RWa', 'RWs'],
                        help='Path generation type: RWc (cyclic), RWa (acyclic), RWs (single source)')
    parser.add_argument('--no_task_tag', action='store_true', default=False,
                        help='Data files do not contain task identifiers (A, B, etc.)')
    parser.add_argument('--local', action='store_true', default=False,
                        help='Disable flash attention for local GPU compatibility')
    parser.add_argument('--NLS', action='store_true', default=False,
                        help='Use NLS model checkpoint (adds _NLS suffix to checkpoint/output filenames)')

    # --- Probe Specific Configuration ---
    parser.add_argument('--probe_tasks', type=str, default='C',
                        help='Which task identifier to probe (e.g., A, C or E)')
    parser.add_argument('--probe_target', type=str, default='current',
                        choices=['current', 'source', 'target', 'rel_direction', 'dist_to_target',
                                 'orientation', 'node_orientation',
                                 'count_F', 'count_L', 'count_R', 'count_T',
                                 'cum_disp_N', 'cum_disp_E', 'cum_disp_S', 'cum_disp_W',
                                 'rot_sum', 'rot_sin', 'rot_cos'])
    parser.add_argument('--probe_train_samples', type=int, default=5000,
                        help='Number of sequences (lines) to sample from training data for probe training')
    parser.add_argument('--probe_test_samples', type=int, default=1000,
                        help='Number of sequences (lines) to sample from test data for probe evaluation')
    parser.add_argument('--probe_batch_size', type=int, default=64,
                        help='Batch size for training the linear probe')
    parser.add_argument('--probe_epochs', type=int, default=5,
                        help='Number of training epochs for the linear probe')
    parser.add_argument('--probe_lr', type=float, default=1e-2,
                        help='Learning rate for the linear probe optimizer')
    parser.add_argument('--probe_eval_bootstrap_samples', type=int, default=100,
                        help='Number of bootstrap samples for standard error estimation')
    parser.add_argument('--probe_eval_on', type=str, default='test', choices=['train', 'test'],
                        help='Evaluate on training set ("train") or test set ("test") (default: test)')

    # --- Position-wise heatmap plot ---
    parser.add_argument('--probe_test_seq_len', type=int, default=None,
                        help='Optional: calculate per-position accuracy for sequences of this specific step length')
    parser.add_argument('--plot_with_tokens', action='store_true', default=True,
                        help='If True, randomly select a valid sequence and use its tokens as X-axis labels in the heatmap. '
                             'The heatmap data will also be restricted to this single sequence.')

    # --- Accuracy-by-distance plot ---
    parser.add_argument('--plot_acc_by_dist', action=argparse.BooleanOptionalAction, default=False,
                        help='If True, additionally plot probe accuracy as a function of graph shortest-path distance '
                             'from the current node to the target node. Only meaningful for classification probes '
                             '(e.g. --probe_target target/current). One curve per layer.')
    parser.add_argument('--plot_acc_by_dist_metric', type=str, default='graph',
                        choices=['graph', 'manhattan'],
                        help='Distance metric used for --plot_acc_by_dist bucketing.')
    parser.add_argument('--plot_acc_by_dist_min_bucket', type=int, default=20,
                        help='Minimum number of samples a distance bucket must contain to be plotted.')

    # --- Task C additions ---
    parser.add_argument('--probe_current_orientation', action=argparse.BooleanOptionalAction, default=False,
                        help='Task C only: probe the agent\'s CURRENT absolute orientation (N/E/S/W) after each step. '
                             'Overrides --probe_target when set. 4-class classification.')
    parser.add_argument('--probe_node_orientation', action=argparse.BooleanOptionalAction, default=True,
                        help='Task C only: jointly probe (current_node, current_orientation). '
                             'Overrides --probe_target when set. (num_nodes * 4)-class classification, '
                             'label = node * 4 + ori_cls with ori_cls in {N:0, E:1, S:2, W:3}.')
    parser.add_argument('--probe_node_orientation_split', action=argparse.BooleanOptionalAction, default=False,
                        help='Task C + --probe_node_orientation only: at evaluation time, split probe accuracy by '
                             '(prev_action, curr_action) buckets in {T, FLR} x {T, FLR} and also report Overall. '
                             'Probe is still trained on the full (no-filter) pool; bucketing happens only during eval.')

    # --- Task E additions ---
    parser.add_argument('--taskE_probe_type', type=str, default='label', choices=['dir', 'label'],
                        help='For Task E, probe at the "dir" token or the "label" token position.')

    # --- Probe MLP architecture ---
    parser.add_argument('--probe_num_layers', type=int, default=1,
                        help='Number of layers in the probe MLP. 1 = single linear layer (default); '
                             '>=2 adds hidden layers with ReLU activations.')
    parser.add_argument('--probe_hidden_dim', type=int, default=None,
                        help='Hidden dimension for the probe MLP when --probe_num_layers > 1. '
                             'Defaults to the input embedding dimension.')

    # --- Non-linear (GELU) probe form ---
    parser.add_argument('--probe_gelu_mlp', action='store_true', default=False,
                        help='Use a 2-layer non-linear probe of the form '
                             'Linear -> GELU -> Linear (state -> hidden -> num_classes), then align '
                             'directly to the one-hot label. Overrides --probe_num_layers (forced to 2) '
                             'and --probe_activation (forced to gelu).')
    parser.add_argument('--probe_activation', type=str, default='relu', choices=['relu', 'gelu'],
                        help='Activation used between probe MLP layers when --probe_num_layers > 1.')

    # --- Control baseline & residual-stream split ---
    parser.add_argument('--random_init', action='store_true', default=False,
                        help='If set, use a randomly-initialized model (same architecture as the checkpoint) '
                             'instead of loading the trained weights. Useful as a control baseline for probing.')
    parser.add_argument('--probe_sublayer_split', action=argparse.BooleanOptionalAction, default=False,
                        help='If set, probe BOTH the post-attn residual stream AND the post-mlp residual stream '
                             'inside every transformer block (instead of just the block output). '
                             'Doubles the number of probe positions per layer.')

    return parser.parse_args()


class LinearProbe(nn.Module):
    """Linear or MLP probe classifier/regressor."""

    def __init__(self, input_dim, num_classes, num_layers=1, hidden_dim=None, activation='relu'):
        super().__init__()
        if num_layers < 1:
            raise ValueError(f"num_layers must be >= 1, got {num_layers}")

        def make_act():
            if activation == 'gelu':
                return nn.GELU()
            elif activation == 'relu':
                return nn.ReLU()
            raise ValueError(f"Unknown activation: {activation}")

        if num_layers == 1:
            self.linear = nn.Linear(input_dim, num_classes)
        else:
            h = hidden_dim if hidden_dim is not None else input_dim
            layers = [nn.Linear(input_dim, h), make_act()]
            for _ in range(num_layers - 2):
                layers += [nn.Linear(h, h), make_act()]
            layers.append(nn.Linear(h, num_classes))
            self.linear = nn.Sequential(*layers)

    def forward(self, x):
        return self.linear(x)


def load_lines(path):
    if not os.path.exists(path): return []
    try:
        with open(path, 'r', encoding='gbk') as f:
            return [line.strip() for line in f if line.strip()]
    except:
        with open(path, 'r', encoding='utf-8') as f:
            return [line.strip() for line in f if line.strip()]


def parse_line_for_probe(line, target_task, probe_target, stoi, no_task_tag, num_nodes, n, taskE_probe_type,
                         maze_graph, model=None, device=None, itos=None):
    """Parses lines and tracks requested information using model predictions for alignment."""
    parts = line.split()
    if ':' not in parts: return None
    colon_idx = parts.index(':')

    labels_chars = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
    turn_chars = {'L', 'R', 'F', 'T'}

    # Determine Task ID and source/target nodes
    try:
        if no_task_tag:
            action_tokens = parts[colon_idx + 1:]
            if any(c in turn_chars for c in action_tokens):
                task_id = 'C'
            elif len(parts) > colon_idx + 2 and parts[colon_idx + 2] in labels_chars:
                task_id = 'E'
            else:
                task_id = 'A'
            source_node = int(parts[0])
            target_node = int(parts[1])
        else:
            task_id = parts[0]
            if task_id not in ['A', 'E', 'C']: return None
            source_node = int(parts[1])
            target_node = int(parts[2])
    except (ValueError, IndexError):
        return None

    if task_id != target_task: return None

    try:
        token_ids = [stoi[t] for t in parts if t in stoi]
        if len(token_ids) < len(parts): return None

        labels = []
        probe_indices = []
        extra_info = []  # 用于存储额外信息，例如预测的 label
        current_nodes = []  # 新增：用于存储当前走到的节点
        prev_acts = []  # Task C only: previous action token at each probe point ('F','L','R','T' or None for i==0)
        curr_acts = []  # Task C only: current (just-executed) action token at each probe point

        tgt_x = target_node % n
        tgt_y = target_node // n

        # Task C orientation -> class index (used when probe_target == 'orientation')
        ORIENT_TO_CLS = {'N': 0, 'E': 1, 'S': 2, 'W': 3}

        def get_label(c_node, orient=None, counts=None, cum_disp=None, rot_sum=None):
            if probe_target == 'current':
                return c_node
            elif probe_target == 'source':
                return source_node
            elif probe_target == 'target':
                return target_node
            elif probe_target == 'rel_direction':
                cur_x = c_node % n
                cur_y = c_node // n
                return [float(tgt_x - cur_x), float(tgt_y - cur_y)]
            elif probe_target == 'orientation':
                # Task C: absolute orientation o_i after the i-th step (4-class N/E/S/W)
                return ORIENT_TO_CLS[orient] if orient is not None else 0
            elif probe_target == 'node_orientation':
                # Task C: joint (node, orientation) -> num_nodes * 4 classes
                ori_cls = ORIENT_TO_CLS[orient] if orient is not None else 0
                return c_node * 4 + ori_cls
            elif probe_target in ('count_F', 'count_L', 'count_R', 'count_T'):
                key = probe_target.split('_')[1]
                return [float(counts.get(key, 0)) if counts is not None else 0.0]
            elif probe_target in ('cum_disp_N', 'cum_disp_E', 'cum_disp_S', 'cum_disp_W'):
                key = probe_target.split('_')[-1]
                return [float(cum_disp.get(key, 0)) if cum_disp is not None else 0.0]
            elif probe_target == 'rot_sum':
                # Task C: un-modded cumulative rotation sum (F=0, L=-1, R=+1, T=+2).
                # orientation_i = (1 + rot_sum_i) mod 4, so this is the pre-mod register.
                return [float(rot_sum) if rot_sum is not None else 0.0]
            elif probe_target == 'rot_sin':
                rs = float(rot_sum) if rot_sum is not None else 0.0
                return [float(np.sin(np.pi / 2.0 * rs))]
            elif probe_target == 'rot_cos':
                rs = float(rot_sum) if rot_sum is not None else 0.0
                return [float(np.cos(np.pi / 2.0 * rs))]
            else:  # dist_to_target: Manhattan distance
                cur_x = c_node % n
                cur_y = c_node // n
                return [float(abs(tgt_x - cur_x) + abs(tgt_y - cur_y))]

        curr = source_node

        # --- 修改点：删除了原本在此处添加 colon_idx 的逻辑，强制从冒号后的动作开始截断 ---

        path_actions = parts[colon_idx + 1:]
        if len(path_actions) == 0: return None  # 如果冒号后没有动作，直接舍弃该行

        if task_id == 'A':
            for i, move in enumerate(path_actions):
                if move == 'N':
                    curr -= n
                elif move == 'S':
                    curr += n
                elif move == 'E':
                    curr += 1
                elif move == 'W':
                    curr -= 1

                if not (0 <= curr < num_nodes): return None

                labels.append(get_label(curr))
                probe_indices.append(colon_idx + 1 + i)
                extra_info.append(None)
                current_nodes.append(curr)  # 记录当前节点
                prev_acts.append(None)
                curr_acts.append(None)

        elif task_id == 'C':
            # Task C：相对转向，起始朝向东方 (E)，每个 action 先转向再移动一步
            left_of = {'N': 'W', 'W': 'S', 'S': 'E', 'E': 'N'}
            right_of = {v: k for k, v in left_of.items()}
            opposite_of = {'N': 'S', 'S': 'N', 'E': 'W', 'W': 'E'}
            delta = {'N': -n, 'S': n, 'E': 1, 'W': -1}
            orientation = 'E'

            def apply_turn(o, a):
                if a == 'F': return o
                if a == 'L': return left_of[o]
                if a == 'R': return right_of[o]
                if a == 'T': return opposite_of[o]
                return None

            # Cumulative action counts (Stage 1 inputs) and cumulative displacement counts (Stage 2 inputs)
            counts = {'F': 0, 'L': 0, 'R': 0, 'T': 0}
            cum_disp = {'N': 0, 'E': 0, 'S': 0, 'W': 0}
            # Un-modded cumulative rotation sum (F=0, L=-1, R=+1, T=+2). orientation_i = (1 + rot_sum) mod 4.
            rot_value = {'F': 0, 'L': -1, 'R': 1, 'T': 2}
            rot_sum = 0

            for i, action in enumerate(path_actions):
                if action not in turn_chars:
                    return None

                next_orientation = apply_turn(orientation, action)
                next_node = curr + delta[next_orientation]
                if not (0 <= next_node < num_nodes): return None

                orientation = next_orientation
                curr = next_node
                counts[action] += 1
                cum_disp[orientation] += 1
                rot_sum += rot_value[action]

                prev_a = path_actions[i - 1] if i > 0 else None
                labels.append(get_label(curr, orient=orientation, counts=counts,
                                        cum_disp=cum_disp, rot_sum=rot_sum))
                probe_indices.append(colon_idx + 1 + i)
                extra_info.append(orientation)  # 记录当前朝向，方便调试
                current_nodes.append(curr)
                prev_acts.append(prev_a)
                curr_acts.append(action)

        elif task_id == 'E':
            skip_simulation = (probe_target in ['target', 'source'])
            inference_ready = (not skip_simulation and taskE_probe_type == 'dir' and model is not None and device is not None)

            for i in range(0, len(path_actions), 2):
                direction = path_actions[i]
                if i + 1 >= len(path_actions): break

                # 若仅需要 Target/Source, 可完全跳过模型推理和走步模拟以大幅加速
                if skip_simulation:
                    target_lab = path_actions[i + 1]
                    if taskE_probe_type == 'dir':
                        labels.append(get_label(curr))
                        probe_indices.append(colon_idx + 1 + i)
                        extra_info.append(target_lab)
                        current_nodes.append("N/A")
                        prev_acts.append(None)
                        curr_acts.append(None)
                    elif taskE_probe_type == 'label':
                        labels.append(get_label(curr))
                        probe_indices.append(colon_idx + 2 + i)
                        extra_info.append(target_lab)
                        current_nodes.append("N/A")
                        prev_acts.append(None)
                        curr_acts.append(None)
                    continue

                # --- 确定目标标签 (Target Label) ---
                if inference_ready:
                    current_seq_len = colon_idx + 1 + i + 1
                    input_seq = torch.tensor([token_ids[:current_seq_len]], dtype=torch.long, device=device)

                    with torch.no_grad():
                        output = model(input_seq)
                        if isinstance(output, tuple):
                            logits = output[0]
                        else:
                            logits = output

                        last_token_logits = logits[0, -1, :]
                        pred_token_id = torch.argmax(last_token_logits).item()
                        target_lab = itos.get(pred_token_id, '<unk>')
                else:
                    target_lab = path_actions[i + 1]

                # --- 模拟行走 ---
                step_count = 0
                temp_curr = curr
                found = False

                while True:
                    if direction == 'N':
                        temp_curr -= n
                    elif direction == 'S':
                        temp_curr += n
                    elif direction == 'E':
                        temp_curr += 1
                    elif direction == 'W':
                        temp_curr -= 1

                    if not (0 <= temp_curr < num_nodes): break
                    step_count += 1
                    if step_count > num_nodes + 5: break

                    node_label = maze_graph.nodes[str(temp_curr)]['label']
                    if node_label == target_lab:
                        curr = temp_curr
                        found = True
                        break

                if not found:
                    return None

                if taskE_probe_type == 'dir':
                    labels.append(get_label(curr))
                    probe_indices.append(colon_idx + 1 + i)
                    extra_info.append(target_lab)
                    current_nodes.append(curr)  # 记录当前节点
                    prev_acts.append(None)
                    curr_acts.append(None)
                elif taskE_probe_type == 'label':
                    labels.append(get_label(curr))
                    probe_indices.append(colon_idx + 2 + i)
                    extra_info.append(target_lab)
                    current_nodes.append(curr)  # 记录当前节点
                    prev_acts.append(None)
                    curr_acts.append(None)

        # 如果最终没有收集到任何有效的探测点，返回 None
        if not labels: return None

        return token_ids, labels, probe_indices, extra_info, current_nodes, prev_acts, curr_acts

    except (ValueError, IndexError):
        return None


def get_probe_data(lines, target_task, probe_target, num_samples, stoi, no_task_tag, num_nodes, n, taskE_probe_type,
                   device, maze_graph, model=None, itos=None):
    candidates = []
    labels_chars = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
    indices = np.random.permutation(len(lines))
    target_count = int(num_samples * 2)

    print(f"Selecting {num_samples} candidate lines for Task {target_task}...")

    for idx in indices:
        line = lines[idx]
        parts = line.split()
        if ':' not in parts: continue
        colon_idx = parts.index(':')

        try:
            if no_task_tag:
                action_tokens = parts[colon_idx + 1:]
                turn_chars = {'L', 'R', 'F', 'T'}
                if any(c in turn_chars for c in action_tokens):
                    line_task = 'C'
                elif len(parts) > colon_idx + 2 and parts[colon_idx + 2] in labels_chars:
                    line_task = 'E'
                else:
                    line_task = 'A'
            else:
                line_task = parts[0]

            if line_task == target_task:
                candidates.append(line)

            if len(candidates) >= target_count:
                break
        except:
            continue

    data = []
    total_probe_points = 0
    for line in tqdm(candidates, desc="Processing Candidates (Model Inference)", leave=False):
        if len(data) >= num_samples: break

        parsed = parse_line_for_probe(line, target_task, probe_target, stoi, no_task_tag, num_nodes, n,
                                      taskE_probe_type, maze_graph, model, device, itos)
        if parsed:
            ids, labels, probe_indices, extra_info, current_nodes, prev_acts, curr_acts = parsed
            total_probe_points += len(labels)
            # Re-parse target_node from the line for distance bucketing
            _parts = line.split()
            try:
                _colon = _parts.index(':')
                if no_task_tag:
                    _tgt_node = int(_parts[1])
                else:
                    _tgt_node = int(_parts[2])
            except (ValueError, IndexError):
                _tgt_node = None
            data.append({'ids': torch.tensor(ids, dtype=torch.long, device=device),
                         'labels': labels,
                         'probe_indices': probe_indices,
                         'extra_info': extra_info,
                         'current_nodes': current_nodes,
                         'prev_acts': prev_acts,
                         'curr_acts': curr_acts,
                         'target_node': _tgt_node})
    print(f"  [debug] sequences={len(data)} | total probe points={total_probe_points}")

    return data


activations = {}


def get_activation_hook(name):
    def hook(model, input, output): activations[name] = output.detach()

    return hook


def get_input_activation_hook(name):
    """Forward pre-hook: capture the FIRST positional input to the module.

    Useful for grabbing the residual stream just BEFORE a sublayer normalization,
    which equals the post-(previous-sublayer) residual stream.
    """
    def hook(model, inputs):
        activations[name] = inputs[0].detach()

    return hook


def bootstrap_accuracy(preds, labels, n_bootstrap=100):
    n_samples = len(preds)
    accuracies = []
    for _ in range(n_bootstrap):
        indices = np.random.choice(n_samples, n_samples, replace=True)
        acc = np.mean(preds[indices] == labels[indices])
        accuracies.append(acc)
    return float(np.mean(accuracies)), float(np.std(accuracies))


def calculate_r2(y_pred, y_true):
    ss_res = np.sum((y_true - y_pred) ** 2)
    ss_tot = np.sum((y_true - np.mean(y_true, axis=0)) ** 2)
    if ss_tot == 0: return 1.0 if ss_res == 0 else 0.0
    return 1 - (ss_res / ss_tot)


def pick_first_existing(candidates):
    for path in candidates:
        if os.path.exists(path): return path
    return candidates[0]


def main():
    args = parse_args()
    torch.manual_seed(42)
    np.random.seed(42)
    random.seed(42)
    grid_n = int(args.num_nodes ** 0.5)

    # --- Resolve probe MLP form override ---
    if args.probe_gelu_mlp:
        args.probe_num_layers = 2
        args.probe_activation = 'gelu'
        print("[probe_gelu_mlp] Probe form: Linear -> GELU -> Linear (2-layer MLP, GELU activation).")

    tasks_tag = f"{args.tasks}_CL" if args.CL else args.tasks
    path_type_tag = args.path_type
    tasks_tag = f"{tasks_tag}_{path_type_tag}"
    if args.no_task_tag:
        tasks_tag += "_NT"

    graph_tag = f"{args.tasks}_CL" if args.CL else args.tasks
    graph_tag = f"{graph_tag}_{path_type_tag}"
    if args.no_task_tag:
        graph_tag += "_NT"

    data_dir = f'data/maze/{args.num_nodes}'
    nt_suffix = '_NT' if args.no_task_tag else ''
    out_dir = f'out/transformer/maze_{args.config}_{args.num_nodes}{nt_suffix}/'
    os.makedirs(out_dir, exist_ok=True)

    # --- Resolve Task C probe overrides BEFORE building filenames ---
    _c_overrides = sum([bool(args.probe_current_orientation),
                        bool(args.probe_node_orientation)])
    if _c_overrides > 1:
        raise ValueError("--probe_current_orientation / --probe_node_orientation "
                         "are mutually exclusive.")
    if args.probe_current_orientation:
        if args.probe_tasks != 'C':
            raise ValueError("--probe_current_orientation is only defined for Task C "
                             f"(got --probe_tasks={args.probe_tasks}).")
        args.probe_target = 'orientation'
    if args.probe_node_orientation:
        if args.probe_tasks != 'C':
            raise ValueError("--probe_node_orientation is only defined for Task C "
                             f"(got --probe_tasks={args.probe_tasks}).")
        args.probe_target = 'node_orientation'

    if args.probe_node_orientation_split and not args.probe_node_orientation:
        raise ValueError("--probe_node_orientation_split requires --probe_node_orientation.")

    eval_on_str = f"_eval_{args.probe_eval_on}"
    excl_tag = ""
    rand_tag = "_rand" if args.random_init else ""
    summary_path = os.path.join(out_dir,
                                f"probe_{args.probe_target}_{args.probe_tasks}{args.taskE_probe_type if args.probe_tasks == 'E' else ''}_{tasks_tag}_{args.ckpt_iter}{eval_on_str}{excl_tag}{rand_tag}.txt")
    detailed_path = os.path.join(out_dir,
                                 f"probe_data_{args.probe_target}_{args.probe_tasks}{args.taskE_probe_type if args.probe_tasks == 'E' else ''}_{tasks_tag}_{args.ckpt_iter}{eval_on_str}{excl_tag}{rand_tag}.txt")

    meta_path = pick_first_existing(
        [os.path.join(data_dir, f'meta_{tasks_tag}.pkl'),
         os.path.join(data_dir, f'meta_{args.tasks}.pkl'),
         os.path.join(data_dir, 'meta.pkl')])
    with open(meta_path, 'rb') as f:
        meta = pickle.load(f)
    stoi, itos = meta['stoi'], meta['itos']

    if args.multitasks:
        maze_graph_path = pick_first_existing([
            f'{data_dir}/maze_graph_{graph_tag}.graphml',
            f'{data_dir}/maze_graph_{args.tasks}.graphml',
            f'{data_dir}/maze_graph.graphml',
        ])
    else:
        maze_graph_path = f'{data_dir}/maze_graph.graphml'

    print(f"Loading Graph from: {maze_graph_path}")
    maze_graph = nx.read_graphml(maze_graph_path)

    train_label = format_count(args.num_train_dataset)
    ckpt_path = pick_first_existing([
        os.path.join(out_dir, f'{args.ckpt_iter}_ckpt_maze_{tasks_tag}_{train_label}.pt'),
        os.path.join(out_dir, f'{args.ckpt_iter}_ckpt_maze_{args.num_of_paths}.pt')
    ])
    print(f"Loading checkpoint from: {ckpt_path}")
    checkpoint = torch.load(ckpt_path, map_location=args.device, weights_only=False)
    conf = GPTConfig(**checkpoint['model_args'])
    if args.local: conf.use_flash = False

    model = GPT(conf)
    if args.random_init:
        print("[random_init] Skipping checkpoint weights; using randomly-initialized model as control.")
    else:
        model.load_state_dict({k.replace('_orig_mod.', ''): v for k, v in checkpoint['model'].items()})
    model.to(args.device).eval()
    for p in model.parameters(): p.requires_grad = False
    print("Model loaded for data generation & probing.")

    train_txt = pick_first_existing([os.path.join(data_dir, f"train_{tasks_tag}_{train_label}.txt"),
                                     os.path.join(data_dir, f'train_{args.num_of_paths}.txt')])
    test_txt = pick_first_existing(
        [os.path.join(data_dir, f"test_{tasks_tag}_{format_count(args.num_test_dataset)}.txt"),
         os.path.join(data_dir, 'test.txt')])

    print(f"Preparing Probe Data | Task: {args.probe_tasks} | Target: {args.probe_target}...")
    if args.probe_target == 'orientation':
        print(f"  [override] --probe_current_orientation enabled -> probe_target='orientation' (4-class N/E/S/W)")
    elif args.probe_target == 'node_orientation':
        print(f"  [override] --probe_node_orientation enabled -> probe_target='node_orientation' "
              f"({args.num_nodes * 4}-class, label = node * 4 + ori_cls)")

    probe_train_data = get_probe_data(load_lines(train_txt), args.probe_tasks, args.probe_target,
                                      args.probe_train_samples, stoi, args.no_task_tag,
                                      args.num_nodes, grid_n, args.taskE_probe_type, args.device, maze_graph,
                                      model=model, itos=itos)
    probe_test_data = get_probe_data(load_lines(test_txt), args.probe_tasks, args.probe_target,
                                     args.probe_test_samples, stoi, args.no_task_tag,
                                     args.num_nodes, grid_n, args.taskE_probe_type, args.device, maze_graph,
                                     model=model, itos=itos)

    eval_data = probe_test_data if args.probe_eval_on == 'test' else probe_train_data
    print(f"Evaluating on {args.probe_eval_on} set ({len(eval_data)} sequences)")

    # --- Pre-select target sequence if plot_with_tokens is enabled ---
    target_seq_id = None
    n_seq_matching_len = 0
    if args.probe_test_seq_len is not None:
        for idx, item in enumerate(eval_data):
            item['global_idx'] = idx
        valid_ids = [idx for idx, item in enumerate(eval_data) if len(item['labels']) == args.probe_test_seq_len]
        n_seq_matching_len = len(valid_ids)
        if args.plot_with_tokens and valid_ids:
            target_seq_id = random.choice(valid_ids)
    # -----------------------------------------------------------------

    print(f"\n--- Ground Truth Verification (10 samples from {args.probe_eval_on} set) ---")
    verification_indices = random.sample(range(len(eval_data)), min(10, len(eval_data)))
    for idx in verification_indices:
        item = eval_data[idx]
        tokens = [itos[t.item()] for t in item['ids']]
        pos_in_labels = random.randint(0, len(item['labels']) - 1)
        p_idx = item['probe_indices'][pos_in_labels]

        prefix_str = " ".join(tokens[:p_idx + 1])

        if args.probe_tasks == 'E' and args.taskE_probe_type == 'dir':
            extra_val = item['extra_info'][pos_in_labels]
            if extra_val and extra_val != "init":
                prefix_str += f" ({extra_val})"

        gt_val = item['labels'][pos_in_labels]
        print(f"Prefix: [{prefix_str}] -> Target: {gt_val}")
    print("-----------------------------------------------\n")

    results_per_layer = []
    bucket_results_per_layer = []
    heatmap_data = []

    _count_targets = ('count_F', 'count_L', 'count_R', 'count_T')
    _cum_disp_targets = ('cum_disp_N', 'cum_disp_E', 'cum_disp_S', 'cum_disp_W')
    is_regression = (args.probe_target in ['rel_direction', 'dist_to_target', 'rot_sum', 'rot_sin', 'rot_cos']
                     or args.probe_target in _count_targets
                     or args.probe_target in _cum_disp_targets)
    # Non-linear (gelu/relu) probes: train classification targets as one-hot regression (MSE)
    # instead of cross-entropy. Evaluation still uses argmax over the output vector.
    onehot_mse = (not is_regression) and (args.probe_num_layers >= 2)
    if onehot_mse:
        print(f"[onehot_mse] num_layers={args.probe_num_layers} ({args.probe_activation}) -> "
              f"training classification probe with MSE-to-one-hot instead of cross-entropy.")
    # Integer-valued regression targets: train with MSE but report rounded-integer accuracy
    use_round_acc = (args.probe_target == 'rot_sum')
    if args.probe_target == 'rel_direction':
        probe_out_dim = 2
    elif args.probe_target == 'dist_to_target':
        probe_out_dim = 1
    elif args.probe_target == 'rot_sum':
        probe_out_dim = 1
    elif args.probe_target in ('rot_sin', 'rot_cos'):
        probe_out_dim = 1
    elif args.probe_target in _count_targets or args.probe_target in _cum_disp_targets:
        probe_out_dim = 1
    elif args.probe_target == 'orientation':
        probe_out_dim = 4  # N/E/S/W
    elif args.probe_target == 'node_orientation':
        probe_out_dim = args.num_nodes * 4  # (node, orientation) joint
    else:
        probe_out_dim = args.num_nodes

    # --- Pre-compute per-probe-point distance from current node to target node ---
    # eval_dist[seq_idx] = list[int|None] aligned with eval_data[seq_idx]['labels']
    eval_dist = None
    if args.plot_acc_by_dist:
        if is_regression:
            print(f"[plot_acc_by_dist] Skipped: probe_target '{args.probe_target}' is regression, not classification.")
            args.plot_acc_by_dist = False
        else:
            print(f"[plot_acc_by_dist] Computing distances ({args.plot_acc_by_dist_metric}) for each probe point...")
            dist_cache = {}

            def _dist(u, v):
                if u is None or v is None or u == "N/A" or v == "N/A":
                    return None
                try:
                    u = int(u); v = int(v)
                except (ValueError, TypeError):
                    return None
                if args.plot_acc_by_dist_metric == 'manhattan':
                    ux, uy = u % grid_n, u // grid_n
                    vx, vy = v % grid_n, v // grid_n
                    return abs(ux - vx) + abs(uy - vy)
                key = (u, v) if u <= v else (v, u)
                if key in dist_cache:
                    return dist_cache[key]
                try:
                    d = nx.shortest_path_length(maze_graph, str(u), str(v))
                except (nx.NetworkXNoPath, nx.NodeNotFound):
                    d = None
                dist_cache[key] = d
                return d

            eval_dist = []
            for item in eval_data:
                tgt = item.get('target_node')
                ds = [_dist(cn, tgt) for cn in item['current_nodes']]
                eval_dist.append(ds)
            n_valid = sum(1 for ds in eval_dist for d in ds if d is not None)
            print(f"[plot_acc_by_dist] Valid probe points with computable distance: {n_valid}")

    # Per-layer per-distance accumulators: dist_correct[layer_idx][d] = [n_correct, n_total]
    dist_acc_per_layer = [{} for _ in range(0)]  # filled below once n_total_layers is known

    # 构建要 probe 的层列表：各个 transformer block + 最后的 LayerNorm (ln_f)
    # 每个元素：(display_name, module, hook_kind)
    #   hook_kind: 'output' -> register_forward_hook (captures module output)
    #              'input'  -> register_forward_pre_hook (captures module input;
    #                          used to grab post-attn residual via ln_2's input)
    if args.probe_sublayer_split:
        layer_targets = []
        for i in range(conf.n_layer):
            # Post-attn residual stream = input to ln_2 (block i)
            layer_targets.append(
                (f"Layer {i + 1} post-attn", model.transformer.h[i].ln_2, 'input'))
            # Post-mlp residual stream = output of block i
            layer_targets.append(
                (f"Layer {i + 1} post-mlp", model.transformer.h[i], 'output'))
    else:
        layer_targets = [(f"Layer {i + 1}", model.transformer.h[i], 'output')
                         for i in range(conf.n_layer)]
    layer_targets.append(("Layer Final (Norm)", model.transformer.ln_f, 'output'))
    n_total_layers = len(layer_targets)

    # Now that n_total_layers is known, allocate the per-layer distance accumulators.
    if args.plot_acc_by_dist:
        dist_acc_per_layer = [{} for _ in range(n_total_layers)]
    else:
        dist_acc_per_layer = None

    for layer_idx, (layer_name, layer_module, hook_kind) in enumerate(layer_targets):
        if hook_kind == 'input':
            hook_handle = layer_module.register_forward_pre_hook(
                get_input_activation_hook('current_layer'))
        else:
            hook_handle = layer_module.register_forward_hook(
                get_activation_hook('current_layer'))
        probe = LinearProbe(conf.n_embd, probe_out_dim,
                            num_layers=args.probe_num_layers,
                            hidden_dim=args.probe_hidden_dim,
                            activation=args.probe_activation).to(args.device)
        optimizer = optim.Adam(probe.parameters(), lr=args.probe_lr)
        criterion = nn.MSELoss() if (is_regression or onehot_mse) else nn.CrossEntropyLoss()

        for epoch in range(args.probe_epochs):
            probe.train()
            perm = np.random.permutation(len(probe_train_data))
            for b_start in range(0, len(probe_train_data), args.probe_batch_size):
                batch_items = [probe_train_data[i] for i in perm[b_start: b_start + args.probe_batch_size]]
                batch_items.sort(key=lambda x: len(x['ids']), reverse=True)
                x_padded = pad_sequence([item['ids'] for item in batch_items], batch_first=True, padding_value=0)
                with torch.no_grad():
                    model(x_padded)
                h_states = activations['current_layer']

                p_in, p_tgt = [], []
                for i, item in enumerate(batch_items):
                    valid_h = h_states[i, item['probe_indices'], :]
                    p_in.append(valid_h)
                    if onehot_mse:
                        lab = torch.tensor(item['labels'], dtype=torch.long, device=args.device)
                        p_tgt.append(torch.nn.functional.one_hot(lab, num_classes=probe_out_dim).float())
                    else:
                        target_type = torch.float if is_regression else torch.long
                        p_tgt.append(torch.tensor(item['labels'], dtype=target_type, device=args.device))

                if not p_in: continue
                optimizer.zero_grad()
                loss = criterion(probe(torch.cat(p_in, 0)), torch.cat(p_tgt, 0))
                loss.backward()
                optimizer.step()

        probe.eval()
        all_preds, all_labels, layer_log_lines = [], [], []
        pos_wise_matches = []
        # For --probe_node_orientation_split: collect per-position (prev_act, curr_act) aligned with preds/labels.
        all_prev_acts, all_curr_acts = [], []

        with torch.no_grad():
            for b_start in range(0, len(eval_data), args.probe_batch_size):
                batch_items = eval_data[b_start: b_start + args.probe_batch_size]
                x_padded = pad_sequence([item['ids'] for item in batch_items], batch_first=True, padding_value=0)
                model(x_padded)
                h_states = activations['current_layer']

                for i, item in enumerate(batch_items):
                    valid_h = h_states[i, item['probe_indices'], :]
                    out = probe(valid_h)

                    actuals_raw = item['labels']
                    if is_regression:
                        preds = out.cpu().numpy()
                        actuals = np.array(actuals_raw)
                    else:
                        preds = torch.argmax(out, dim=1).cpu().numpy()
                        actuals = np.array(actuals_raw)

                    all_preds.append(preds)
                    all_labels.append(actuals)
                    if args.probe_node_orientation_split:
                        all_prev_acts.extend(item.get('prev_acts', [None] * len(preds)))
                        all_curr_acts.extend(item.get('curr_acts', [None] * len(preds)))

                    # --- Accumulate per-distance accuracy for this layer ---
                    if args.plot_acc_by_dist and eval_dist is not None and not is_regression:
                        seq_global_idx = b_start + i
                        ds = eval_dist[seq_global_idx]
                        bucket = dist_acc_per_layer[layer_idx]
                        for step_idx, d in enumerate(ds):
                            if d is None:
                                continue
                            if d not in bucket:
                                bucket[d] = [0, 0]
                            bucket[d][1] += 1
                            if preds[step_idx] == actuals[step_idx]:
                                bucket[d][0] += 1

                    if args.probe_test_seq_len is not None and len(actuals) == args.probe_test_seq_len:
                        # Modified to include `item` for token extraction later
                        pos_wise_matches.append((preds, actuals, item))

                    full_tokens = [itos[t.item()] for t in item['ids']]
                    for step_idx, p_idx in enumerate(item['probe_indices']):
                        prefix_str = ' '.join(full_tokens[:p_idx + 1])
                        if args.probe_tasks == 'E' and args.taskE_probe_type == 'dir':
                            extra_val = item['extra_info'][step_idx]
                            if extra_val and extra_val != "init":
                                prefix_str += f" ({extra_val})"

                        p_val, a_val = preds[step_idx], actuals[step_idx]
                        res = "OK" if np.allclose(p_val, a_val, atol=0.5) else f"ERR(Real:{a_val})"
                        layer_log_lines.append(f"Prefix:[{prefix_str}] | Pred:{p_val} | {res}")

        with open(detailed_path, 'a') as f_det:
            f_det.write(f"--- {layer_name} ---\n")
            sampled_lines = random.sample(layer_log_lines, min(len(layer_log_lines), 1000))
            for line in sampled_lines: f_det.write(line + "\n")
            f_det.write("\n")

        all_preds_cat = np.concatenate(all_preds, axis=0)
        all_labels_cat = np.concatenate(all_labels, axis=0)

        if is_regression:
            if use_round_acc:
                p_int = np.round(np.asarray(all_preds_cat).reshape(-1)).astype(np.int64)
                l_int = np.round(np.asarray(all_labels_cat).reshape(-1)).astype(np.int64)
                acc = float(np.mean(p_int == l_int))
                results_per_layer.append(acc)
                print(f"{layer_name} Overall Accuracy ({args.probe_target}, rounded): {acc * 100:.2f}%")
            else:
                r2 = calculate_r2(all_preds_cat, all_labels_cat)
                results_per_layer.append(r2)
                print(f"{layer_name} Overall R^2 Score ({args.probe_target}): {r2:.4f}")
        else:
            mean_acc, std_acc = bootstrap_accuracy(all_preds_cat, all_labels_cat, args.probe_eval_bootstrap_samples)
            results_per_layer.append((mean_acc, std_acc))
            print(f"{layer_name} Overall Accuracy ({args.probe_target}): {mean_acc * 100:.2f}% ± {std_acc * 100:.2f}%")

        # --- Optional (prev, curr) bucket evaluation for node_orientation ---
        if args.probe_node_orientation_split and not is_regression:
            prev_arr = np.array(all_prev_acts, dtype=object)
            curr_arr = np.array(all_curr_acts, dtype=object)
            bucket_specs = [('T', 'T'), ('T', 'FLR'), ('FLR', 'T'), ('FLR', 'FLR')]
            bucket_results = {}
            print(f"  [{layer_name}] bucketed:", end='')
            for pv, cv in bucket_specs:
                mask = np.zeros(len(prev_arr), dtype=bool)
                for k in range(len(prev_arr)):
                    pa, ca = prev_arr[k], curr_arr[k]
                    if pa is None or ca is None:
                        continue
                    pa_v = 'T' if pa == 'T' else 'FLR'
                    ca_v = 'T' if ca == 'T' else 'FLR'
                    if pa_v == pv and ca_v == cv:
                        mask[k] = True
                if mask.sum() == 0:
                    bucket_results[(pv, cv)] = (0.0, 0.0, 0)
                    continue
                sp = all_preds_cat[mask]
                sl = all_labels_cat[mask]
                m, s = bootstrap_accuracy(sp, sl, args.probe_eval_bootstrap_samples)
                bucket_results[(pv, cv)] = (m, s, int(mask.sum()))
                print(f"  prev={pv},curr={cv}: {m*100:.2f}% (n={int(mask.sum())})", end='')
            print()
            if 'bucket_results_per_layer' not in locals():
                bucket_results_per_layer = []
            bucket_results_per_layer.append(bucket_results)

        if args.probe_test_seq_len is not None:
            # --- Ensure heatmap data is restricted to the chosen sequence if plot_with_tokens is True ---
            if args.plot_with_tokens and target_seq_id is not None:
                pos_wise_matches = [m for m in pos_wise_matches if m[2].get('global_idx') == target_seq_id]

            if layer_idx == 0:
                if args.plot_with_tokens:
                    print(
                        f"--- Generating heatmap for a single selected sequence with {args.probe_test_seq_len} steps ---")
                else:
                    print(
                        f"--- Found {len(pos_wise_matches)} sequences with exactly {args.probe_test_seq_len} steps ---")

            if len(pos_wise_matches) > 0:
                pos_metrics = []
                for p_idx in range(args.probe_test_seq_len):
                    p_at_pos = np.array([m[0][p_idx] for m in pos_wise_matches])
                    l_at_pos = np.array([m[1][p_idx] for m in pos_wise_matches])
                    if is_regression and not use_round_acc:
                        m_val = calculate_r2(p_at_pos, l_at_pos)
                    else:
                        p_cmp = np.round(p_at_pos.reshape(-1)).astype(np.int64) if use_round_acc else p_at_pos
                        l_cmp = np.round(l_at_pos.reshape(-1)).astype(np.int64) if use_round_acc else l_at_pos
                        m_val = float(np.mean(p_cmp == l_cmp))
                    pos_metrics.append(m_val)
                heatmap_data.append(pos_metrics)

        hook_handle.remove()

    if args.probe_test_seq_len is not None and len(heatmap_data) == n_total_layers:
        heatmap_array = np.array(heatmap_data)
        fig, ax = plt.subplots(figsize=(max(12, args.probe_test_seq_len * 0.6), max(5, n_total_layers * 0.6)))
        _scalar_acc = (not is_regression) or use_round_acc
        im = ax.imshow(heatmap_array, cmap='coolwarm', aspect='equal', vmin=0 if _scalar_acc else None,
                       vmax=1 if _scalar_acc else None)
        fig.colorbar(im, ax=ax, label='Accuracy' if _scalar_acc else 'R^2 Score')
        if args.plot_with_tokens and target_seq_id is not None:
            n_used = 1
            title_seq_info = f'1 of {n_seq_matching_len} seq (single, with tokens)'
        else:
            n_used = len(pos_wise_matches)
            title_seq_info = f'avg over {n_used} seq'
        ax.set_title(
            f'Position-wise Probe Performance ({args.probe_target}) | Seq Len {args.probe_test_seq_len} | Eval on {args.probe_eval_on} | {title_seq_info}')
        ax.set_xlabel('Position in Sequence')
        ax.set_ylabel('Layer')
        ax.set_yticks(range(n_total_layers))
        ax.set_yticklabels([t[0] for t in layer_targets])
        ax.set_xticks(range(args.probe_test_seq_len))

        # --- Logic for Dynamic Token X-Axis Labels ---
        x_labels = [f'{i}' for i in range(args.probe_test_seq_len)]  # Default 0, 1, 2...
        rotation = 0
        ha = 'center'

        if args.plot_with_tokens and len(pos_wise_matches) > 0:
            # Because pos_wise_matches is already filtered, [0] is exactly our target
            selected_sample = pos_wise_matches[0][2]
            tokens = [itos[t.item()] for t in selected_sample['ids']]
            probe_indices = selected_sample['probe_indices']
            nodes_history = selected_sample['current_nodes']  # 获取节点历史

            new_x_labels = []
            last_idx = 0
            # 使用 enumerate 获取索引以访问 nodes_history
            for k, p_idx in enumerate(probe_indices):
                # Get the chunk of tokens ending at the probe point
                chunk = tokens[last_idx:p_idx + 1]
                node_id = nodes_history[k]  # 获取当前节点

                # 格式化：Token 前缀 + 换行 + 节点ID
                label_str = f"{' '.join(chunk)}\n({node_id})"
                new_x_labels.append(label_str)
                last_idx = p_idx + 1

            x_labels = new_x_labels
            rotation = 45  # Rotate slightly to prevent overlap of long tokens like "A 26 37 : E"
            ha = 'right'

        ax.set_xticklabels(x_labels, rotation=rotation, ha=ha)

        # --- Highlight labels with perfect accuracy (1.0) ---
        # We iterate through the x-axis labels and check the corresponding value in the last layer of heatmap
        for i, label in enumerate(ax.get_xticklabels()):
            if heatmap_array.shape[1] > i:
                val = heatmap_array[-1, i]  # Value at last layer for position i
                # Check if accuracy/R2 is effectively 1.0 (using a small tolerance for float precision)
                if abs(val - 1.0) < 1e-4:
                    label.set_color('red')
        # -----------------------------------------------

        for i in range(n_total_layers):
            for j in range(args.probe_test_seq_len):
                ax.text(j, i, f"{heatmap_array[i, j]:.2f}", ha="center", va="center", color="white", fontsize=8)

        fig.tight_layout()

        # Add 'single' suffix to output filename if token plotting is enabled to differentiate
        single_suffix = "_single" if args.plot_with_tokens else ""
        plot_filename = os.path.join(out_dir,
                                     f"probe_heatmap_{args.probe_target}_{args.probe_tasks}{args.taskE_probe_type if args.probe_tasks == 'E' else ''}_{tasks_tag}_{args.ckpt_iter}_len{args.probe_test_seq_len}{eval_on_str}{single_suffix}{rand_tag}.png")
        fig.savefig(plot_filename, dpi=300)
        plt.close(fig)
        print(f"\nPosition-wise heatmap saved to: {plot_filename}")

    separator = "=" * 60
    with open(summary_path, 'w') as f_sum:
        f_sum.write(f"{separator}\n")
        f_sum.write(f"Probing Test Results: {args.probe_target.upper()} | Task: {args.probe_tasks}\n")
        f_sum.write(f"{separator}\n")
        f_sum.write(f"Config: {args.config}\n")
        f_sum.write(f"Checkpoint iteration: {args.ckpt_iter}\n")
        f_sum.write(f"Number of nodes: {args.num_nodes}\n")
        f_sum.write(f"Probing target: {args.probe_target}\n")
        if args.probe_tasks == 'E': f_sum.write(f"Task E Probe Type: {args.taskE_probe_type}\n")
        if args.probe_test_seq_len is not None: f_sum.write(
            f"Position-wise test for seq length: {args.probe_test_seq_len}\n")
        f_sum.write(f"Evaluated on: {args.probe_eval_on} set\n")
        f_sum.write(f"{separator}\n\n")
        for l, val in enumerate(results_per_layer):
            _as_acc = (not is_regression) or use_round_acc
            metric_name = "Accuracy" if _as_acc else "R^2"
            if isinstance(val, tuple):
                mean_v, std_v = val
                metric_val = f"{mean_v * 100:.4f}% ± {std_v * 100:.4f}%"
            else:
                metric_val = f"{val * 100:.4f}%" if _as_acc else f"{val:.4f}"
            layer_display = layer_targets[l][0] if l < len(layer_targets) else f"Layer {l + 1}"
            f_sum.write(f"{layer_display}: {metric_name} = {metric_val}\n")
        f_sum.write(f"\n{separator}\n")

        if args.probe_node_orientation_split and bucket_results_per_layer:
            f_sum.write("\n--- (prev_action, curr_action) bucket accuracies ---\n")
            f_sum.write(f"{'Layer':<14} {'T,T':>20} {'T,FLR':>20} {'FLR,T':>20} {'FLR,FLR':>20} {'Overall':>20}\n")
            for l, br in enumerate(bucket_results_per_layer):
                layer_display = layer_targets[l][0] if l < len(layer_targets) else f"Layer {l + 1}"
                cells = []
                for key in [('T', 'T'), ('T', 'FLR'), ('FLR', 'T'), ('FLR', 'FLR')]:
                    m, s, n = br.get(key, (0.0, 0.0, 0))
                    cells.append(f"{m*100:.2f}±{s*100:.2f}(n={n})")
                overall = results_per_layer[l]
                if isinstance(overall, tuple):
                    o_cell = f"{overall[0]*100:.2f}±{overall[1]*100:.2f}"
                else:
                    o_cell = f"{overall*100:.2f}"
                f_sum.write(f"{layer_display:<14} {cells[0]:>20} {cells[1]:>20} {cells[2]:>20} {cells[3]:>20} {o_cell:>20}\n")
            f_sum.write(f"{separator}\n")

    print(f"\nDone. Summary saved to: {summary_path}")

    # --- Optional: plot probe accuracy vs distance-to-target ---
    if args.plot_acc_by_dist and dist_acc_per_layer is not None:
        min_n = args.plot_acc_by_dist_min_bucket
        # Union of all distances seen across layers (they should be the same set)
        all_dists = sorted({d for layer_buckets in dist_acc_per_layer for d in layer_buckets.keys()})
        # Keep only distances whose total count (summed across layers / all == any layer's count) >= min_n
        valid_dists = []
        for d in all_dists:
            # All layers share the same denominators because they're computed on the same probe points
            totals = [dist_acc_per_layer[l].get(d, [0, 0])[1] for l in range(n_total_layers)]
            if max(totals) >= min_n:
                valid_dists.append(d)

        if not valid_dists:
            print(f"[plot_acc_by_dist] No distance bucket has >= {min_n} samples; skipping plot.")
        else:
            fig, ax = plt.subplots(figsize=(max(8, len(valid_dists) * 0.5), 5))
            cmap = plt.get_cmap('viridis', n_total_layers)
            for l in range(n_total_layers):
                xs, ys, ns = [], [], []
                for d in valid_dists:
                    n_corr, n_tot = dist_acc_per_layer[l].get(d, [0, 0])
                    if n_tot < min_n:
                        continue
                    xs.append(d)
                    ys.append(n_corr / n_tot)
                    ns.append(n_tot)
                if not xs:
                    continue
                ax.plot(xs, ys, marker='o', color=cmap(l), label=layer_targets[l][0])

            ax.set_xlabel(f"Distance from current node to target ({args.plot_acc_by_dist_metric})")
            ax.set_ylabel("Probe accuracy")
            ax.set_ylim(0, 1.02)
            ax.set_title(
                f"Probe Accuracy vs Distance-to-Target | target={args.probe_target} | "
                f"task={args.probe_tasks} | eval={args.probe_eval_on}"
            )
            ax.grid(True, alpha=0.3)
            ax.legend(loc='best', fontsize=8)
            # Annotate bucket sizes on the bottom layer's curve (use last layer for clarity)
            last_bucket = dist_acc_per_layer[-1]
            for d in valid_dists:
                n_corr, n_tot = last_bucket.get(d, [0, 0])
                if n_tot >= min_n:
                    ax.annotate(f"n={n_tot}", xy=(d, 0.02), ha='center', va='bottom',
                                fontsize=7, color='gray', rotation=90)
            fig.tight_layout()

            dist_plot_path = os.path.join(
                out_dir,
                f"probe_acc_by_dist_{args.probe_target}_{args.probe_tasks}"
                f"{args.taskE_probe_type if args.probe_tasks == 'E' else ''}_"
                f"{tasks_tag}_{args.ckpt_iter}{eval_on_str}{excl_tag}{rand_tag}_"
                f"{args.plot_acc_by_dist_metric}.png"
            )
            fig.savefig(dist_plot_path, dpi=300)
            plt.close(fig)
            print(f"[plot_acc_by_dist] Saved plot to: {dist_plot_path}")

            # Also dump a CSV so the numbers are inspectable
            csv_path = dist_plot_path.replace('.png', '.csv')
            with open(csv_path, 'w') as f_csv:
                header = ['distance'] + [layer_targets[l][0] + '_acc' for l in range(n_total_layers)] + \
                         [layer_targets[l][0] + '_n' for l in range(n_total_layers)]
                f_csv.write(','.join(header) + '\n')
                for d in valid_dists:
                    row = [str(d)]
                    for l in range(n_total_layers):
                        n_corr, n_tot = dist_acc_per_layer[l].get(d, [0, 0])
                        row.append(f"{(n_corr / n_tot):.6f}" if n_tot > 0 else "")
                    for l in range(n_total_layers):
                        n_corr, n_tot = dist_acc_per_layer[l].get(d, [0, 0])
                        row.append(str(n_tot))
                    f_csv.write(','.join(row) + '\n')
            print(f"[plot_acc_by_dist] Saved data to: {csv_path}")


if __name__ == "__main__":
    main()