analyze_maze.py

import os
import argparse
import math
from cli_utils import parse_count, format_count


def analyze_maze_predictions(file_path, multitasks=False, no_task_tag=False):
    """

    Analyze maze predictions from test output file.



    Args:

        file_path: Path to the prediction file

        multitasks: If True, separate analysis for Task A and Task B

        no_task_tag: If True, data files do not contain task identifiers



    Returns:

        Dictionary with overall stats and per-task stats if multitasks=True

    """
    total = 0
    correct = 0
    illegal_direction = 0
    incorrect_target = 0
    syntax_error = 0
    overall_high_conf = 0
    overall_low_conf = 0

    # Per-task statistics
    taskA_stats = {'total': 0, 'correct': 0, 'syntax_error': 0, 'illegal_direction': 0, 'incorrect_target': 0,
                   'high_conf_mistake': 0, 'low_conf_mistake': 0}
    taskB_stats = {'total': 0, 'correct': 0, 'syntax_error': 0, 'incorrect_target_label': 0, 'incorrect_neighbor_label': 0,
                   'high_conf_mistake': 0, 'low_conf_mistake': 0}
    taskC_stats = {'total': 0, 'correct': 0, 'syntax_error': 0, 'illegal_direction': 0, 'incorrect_target': 0,
                   'incorrect_label': 0, 'high_conf_mistake': 0, 'low_conf_mistake': 0}
    taskD_stats = {'total': 0, 'correct': 0, 'syntax_error': 0, 'illegal_direction': 0, 'incorrect_target': 0,
                   'high_conf_mistake': 0, 'low_conf_mistake': 0}
    taskE_stats = {'total': 0, 'correct': 0, 'syntax_error': 0, 'illegal_direction': 0, 'incorrect_target': 0,
                   'incorrect_label': 0, 'high_conf_mistake': 0, 'low_conf_mistake': 0}
    taskF_stats = {'total': 0, 'correct': 0, 'syntax_error': 0, 'incorrect_target_label': 0,
                   'high_conf_mistake': 0, 'low_conf_mistake': 0}
    taskG_stats = {'total': 0, 'correct': 0, 'syntax_error': 0, 'illegal_direction': 0, 'incorrect_target': 0,
                   'high_conf_mistake': 0, 'low_conf_mistake': 0}
    taskH_stats = {'total': 0, 'correct': 0, 'syntax_error': 0, 'illegal_direction': 0, 'incorrect_target': 0,
                   'high_conf_mistake': 0, 'low_conf_mistake': 0}

    task_stats_map = {
        'A': taskA_stats, 'B': taskB_stats, 'C': taskC_stats,
        'D': taskD_stats, 'E': taskE_stats, 'F': taskF_stats, 'G': taskG_stats,
        'H': taskH_stats
    }

    with open(file_path, 'r') as f:
        for line in f:
            line = line.strip()
            if not line:
                continue
            total += 1

            parts = line.split()

            # Detect task ID (A, B, C, D, E, F, G)
            task_id = None
            task_offset = 0

            if not no_task_tag:
                # Original logic with task tags
                if len(parts) > 0 and parts[0] in ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']:
                    task_id = parts[0]
                    task_offset = 1
            else:
                # In no_task_tag mode, read task type from parentheses in the line
                if line.startswith('(') and ')' in line:
                    end_paren = line.find(')')
                    task_id_str = line[1:end_paren]
                    if task_id_str in ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']:
                        task_id = task_id_str
                        line_without_label = line[end_paren+1:].strip()
                        parts = line_without_label.split()
                        task_offset = 0

            if task_id is None:
                if ':' in line:
                    colon_idx = line.index(':')
                    prompt_part = line[:colon_idx].strip()
                    prompt_tokens = prompt_part.split()

                    if len(prompt_tokens) >= 2:
                        answer_part = line[colon_idx + 1:].strip()
                        answer_tokens = answer_part.split()
                        if len(answer_tokens) >= 2 and answer_tokens[1] in ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']:
                            task_id = 'E'
                        elif any(tok in ['L', 'R', 'F', 'T'] for tok in answer_tokens):
                            task_id = 'C'
                        elif len(prompt_tokens) == 2 and prompt_tokens[0].isdigit() and prompt_tokens[1].isdigit():
                            task_id = 'A'
                        elif prompt_tokens[0].isdigit() and prompt_tokens[1] in ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']:
                            task_id = 'D'
                        elif prompt_tokens[0] in ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']:
                            task_id = 'F'
                        elif len(prompt_tokens) == 4 and all(token.isdigit() for token in prompt_tokens):
                            task_id = 'G'
                        elif prompt_tokens[0].isdigit():
                            if len(answer_tokens) == 5:
                                task_id = 'B'

            if multitasks and task_id in task_stats_map:
                task_stats_map[task_id]['total'] += 1

            # Confidence tracking
            is_high = 'HIGH-CONF' in line
            is_low = 'LOW-CONF' in line
            if is_high:
                overall_high_conf += 1
                if task_id in task_stats_map:
                    task_stats_map[task_id]['high_conf_mistake'] += 1
            elif is_low:
                overall_low_conf += 1
                if task_id in task_stats_map:
                    task_stats_map[task_id]['low_conf_mistake'] += 1

            if 'is illegal' in line or 'exceeds feasible count' in line or 'invalid index' in line or 'no feasible edges' in line:
                illegal_direction += 1
                if task_id in task_stats_map and 'illegal_direction' in task_stats_map[task_id]:
                    task_stats_map[task_id]['illegal_direction'] += 1
                continue

            if 'syntax error' in line:
                syntax_error += 1
                if task_id in task_stats_map:
                    task_stats_map[task_id]['syntax_error'] += 1
                continue

            if 'incorrect neighbor label' in line:
                if task_id == 'B':
                    taskB_stats['incorrect_neighbor_label'] += 1
                incorrect_target += 1
                continue

            if 'incorrect target node label' in line:
                if task_id == 'B':
                    taskB_stats['incorrect_target_label'] += 1
                incorrect_target += 1
                continue

            if 'incorrect target label' in line:
                if task_id == 'F':
                    taskF_stats['incorrect_target_label'] += 1
                incorrect_target += 1
                continue

            if 'incorrect label' in line:
                if task_id == 'C':
                    taskC_stats['incorrect_label'] += 1
                elif task_id == 'E':
                    taskE_stats['incorrect_label'] += 1
                incorrect_target += 1
                continue

            if 'incorrect target node' in line:
                incorrect_target += 1
                if task_id in task_stats_map and 'incorrect_target' in task_stats_map[task_id]:
                    task_stats_map[task_id]['incorrect_target'] += 1
                continue

            correct += 1
            if task_id in task_stats_map:
                task_stats_map[task_id]['correct'] += 1

    stats = {
        'total': total,
        'correct': correct,
        'syntax_error': syntax_error,
        'illegal_direction': illegal_direction,
        'incorrect_target': incorrect_target,
        'high_conf_mistake': overall_high_conf,
        'low_conf_mistake': overall_low_conf
    }

    if multitasks:
        stats['taskA'] = taskA_stats
        stats['taskB'] = taskB_stats
        stats['taskC'] = taskC_stats
        stats['taskD'] = taskD_stats
        stats['taskE'] = taskE_stats
        stats['taskF'] = taskF_stats
        stats['taskG'] = taskG_stats
        stats['taskH'] = taskH_stats

    return stats


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='Analyze prediction results from test_maze.py')
    parser.add_argument('--ckpt_iter', type=int, default=10000, help='Checkpoint iteration')
    parser.add_argument('--model', type=str, default='transformer', choices=['transformer', 'transformer-rope', 'transformer-nextlat', 'mamba', 'mamba2', 'gated-deltanet', 'gru'],
                        help='Model architecture; selects the out/<model>/ directory')
    parser.add_argument('--config', type=str, default='1_1_120', help='Model config')
    parser.add_argument('--dataset', type=str, default='maze', help='Dataset name')
    parser.add_argument('--num_nodes', type=int, default=100, help='Number of nodes')
    parser.add_argument('--num_of_paths', type=int, default=20, help='Number of paths')
    parser.add_argument('--multitasks', action=argparse.BooleanOptionalAction, default=True,
                        help='Use multitask data (default: True)')
    parser.add_argument('--num_train_dataset', type=parse_count, default=50000,
                        help='Number of multitask training entries (supports K/M/B, default: 50000)')
    parser.add_argument('--num_test_dataset', type=parse_count, default=10000,
                        help='Number of multitask test entries (supports K/M/B, default: 10000)')
    parser.add_argument('--tasks', type=str, default='A1',
                        help='Task specification (e.g., A1, A1B1, A3B2, A1D1F1). Default: A1')
    parser.add_argument('--CL', action=argparse.BooleanOptionalAction, default=False,
                        help='Task C turn-label mode (default: False)')
    parser.add_argument('--batch_size', type=int, default=100,
                        help='Batch size used during prediction (matches test_maze.py)')
    parser.add_argument('--num_iters', type=int, default=10,
                        help='Number of batches used during prediction (matches test_maze.py)')
    parser.add_argument('--path_type', type=str, default='RWa', choices=['RWc', 'RWa', 'RWs'],
                        help='Path generation type: RWc (random walk with cycles), RWa (random walk acyclic, default), RWs (single source random walk).')
    parser.add_argument('--partial', action='store_true', default=False,
                        help='Analyze partial prefix test results (default: False)')
    parser.add_argument('--temperature', type=float, default=1.0,
                        help='Sampling temperature used during prediction (default: 1.0). Affects output filenames.')
    # Add --no_task_tag argument
    parser.add_argument('--no_task_tag', action='store_true', default=False,
                        help='Data files do not contain task identifiers (A, B, C, etc.). This should match the setting used during data generation and testing.')
    parser.add_argument('--PostGRU', action='store_true', default=False,
                        help='Analyze PostGRU predictions (adds _PGR suffix to filenames)')
    parser.add_argument('--NLS', action='store_true', default=False,
                        help='Analyze NLS predictions (adds _NLS suffix to filenames)')
    args = parser.parse_args()

    tasks_str = args.tasks
    tasks_tag = f"{tasks_str}_CL" if args.CL else tasks_str
    # Add path type tag for filenames (RWc = cyclic, RWa = acyclic, RWs = single source)
    path_type_tag = args.path_type
    tasks_tag = f"{tasks_tag}_{path_type_tag}"
    # Add _NT_ tag to tasks_tag when no_task_tag is enabled
    if args.no_task_tag:
        tasks_tag = f"{tasks_tag}_NT"
    # Add _NL tag for transformer-nextlat
    if args.model == 'transformer-nextlat':
        tasks_tag = f"{tasks_tag}_NL"
    # Add _PGR tag when PostGRU is enabled
    if args.PostGRU:
        tasks_tag = f"{tasks_tag}_PGR"
    # Add _NLS tag when NLS is enabled
    if args.NLS:
        tasks_tag = f"{tasks_tag}_NLS"
    test_dataset_label = format_count(args.num_test_dataset)
    run_test_label = args.batch_size * args.num_iters
    nt_suffix = '_NT' if args.no_task_tag else ''
    out_dir = f'out/{args.model.replace("-", "_")}/{args.dataset}_{args.config}_{args.num_nodes}{nt_suffix}/'


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


    # Add _partial suffix if partial mode is enabled
    partial_suffix = '_partial' if args.partial else ''
    # Add temperature suffix when temperature is not default (1.0)
    temp_suffix = f'_t{args.temperature}' if args.temperature != 1.0 else ''

    pred_candidates = (
        [
            os.path.join(out_dir, f'pred_test_{tasks_tag}_{args.ckpt_iter}_{run_test_label}{temp_suffix}{partial_suffix}.txt'),
            # primary (matches test_maze.py)
            os.path.join(out_dir, f'pred_test_{tasks_tag}_{args.ckpt_iter}_{test_dataset_label}{temp_suffix}{partial_suffix}.txt'),
            os.path.join(out_dir,
                         f'pred_test_{tasks_tag}_{args.ckpt_iter}_{args.num_test_dataset}{temp_suffix}{partial_suffix}.txt'),
            os.path.join(out_dir, f'pred_test_{tasks_str}_{args.ckpt_iter}_{run_test_label}{temp_suffix}{partial_suffix}.txt'),
            os.path.join(out_dir, f'pred_test_{tasks_str}_{args.ckpt_iter}_{test_dataset_label}{temp_suffix}{partial_suffix}.txt'),
            os.path.join(out_dir,
                         f'pred_test_{tasks_str}_{args.ckpt_iter}_{args.num_test_dataset}{temp_suffix}{partial_suffix}.txt'),
        ]
        if args.multitasks else [
            os.path.join(out_dir, f'pred_test_{args.ckpt_iter}_{args.num_of_paths}{temp_suffix}{partial_suffix}.txt')]
    )
    file_path = pick_first_existing(pred_candidates)

    if os.path.exists(file_path):
        # Ensure output directory exists
        os.makedirs(out_dir, exist_ok=True)

        # Analyze predictions
        stats = analyze_maze_predictions(file_path, multitasks=args.multitasks, no_task_tag=args.no_task_tag)


        def pct_and_se(count, total):
            if total <= 0:
                return 0.0, 0.0
            p = count / total
            se = math.sqrt(p * (1 - p) / total) * 100
            return p * 100, se


        # Format output
        separator = "=" * 70
        output_lines = [
            separator,
            "Accuracy Test Results",
            separator,
            f"Task tag: {'DISABLED' if args.no_task_tag else 'ENABLED'}",
            f"Config: {args.config}",
            f"Checkpoint iteration: {args.ckpt_iter}",
            f"Number of nodes: {args.num_nodes}",
            f"Task configuration: {args.tasks}" if args.multitasks else "",
            separator,
        ]

        # Overall statistics
        total_preds = stats['total'] if stats['total'] > 0 else 1
        corr_pct, corr_se = pct_and_se(stats['correct'], total_preds)
        syn_pct, _ = pct_and_se(stats['syntax_error'], total_preds)
        ill_pct, _ = pct_and_se(stats['illegal_direction'], total_preds)
        tgt_pct, _ = pct_and_se(stats['incorrect_target'], total_preds)
        high_pct, _ = pct_and_se(stats['high_conf_mistake'], total_preds)
        low_pct, _ = pct_and_se(stats['low_conf_mistake'], total_preds)

        output_lines.extend([
            "OVERALL STATISTICS:",
            f"  Total predictions: {stats['total']}",
            f"  Correct (accuracy with standard error): {stats['correct']} ({corr_pct:.2f}% ± {corr_se:.2f}%)",
            f"  Syntax error: {stats['syntax_error']} ({syn_pct:.2f}%)",
            f"  Illegal direction: {stats['illegal_direction']} ({ill_pct:.2f}%)",
            f"  Incorrect target: {stats['incorrect_target']} ({tgt_pct:.2f}%)",
            f"    - High confidence mistakes: {stats['high_conf_mistake']} ({high_pct:.2f}%)",
            f"    - Low confidence mistakes: {stats['low_conf_mistake']} ({low_pct:.2f}%)",
        ])

        # Per-task statistics if multitasks
        if args.multitasks:
            task_mapping = {
                'taskA': ('A', 'Pathfinding'),
                'taskB': ('B', 'Target Identification'),
                'taskC': ('C', 'Turn-based pathfinding'),
                'taskD': ('D', 'Pathfinding to label'),
                'taskE': ('E', 'Pathfinding with labels'),
                'taskF': ('F', 'Target label identification'),
                'taskG': ('G', 'Reachability choice'),
                'taskH': ('H', 'Relative clockwise-index path')
            }

            for key, (tid, name) in task_mapping.items():
                if key in stats and stats[key]['total'] > 0:
                    s = stats[key]
                    t_total = s['total']
                    t_corr, t_se = pct_and_se(s['correct'], t_total)
                    t_syn, _ = pct_and_se(s['syntax_error'], t_total)
                    t_high, _ = pct_and_se(s['high_conf_mistake'], t_total)
                    t_low, _ = pct_and_se(s['low_conf_mistake'], t_total)

                    output_lines.extend([
                        "",
                        separator,
                        f"TASK {tid} ({name}) STATISTICS:",
                        f"  Total: {t_total}",
                        f"  Correct (accuracy with standard error): {s['correct']} ({t_corr:.2f}% ± {t_se:.2f}%)",
                        f"  Syntax error: {s['syntax_error']} ({t_syn:.2f}%)",
                    ])

                    if 'illegal_direction' in s:
                        t_ill, _ = pct_and_se(s['illegal_direction'], t_total)
                        output_lines.append(f"  Illegal direction: {s['illegal_direction']} ({t_ill:.2f}%)")

                    if tid == 'B':
                        t_lbl, _ = pct_and_se(s['incorrect_target_label'], t_total)
                        t_nbr, _ = pct_and_se(s['incorrect_neighbor_label'], t_total)
                        output_lines.append(
                            f"  Incorrect target node label: {s['incorrect_target_label']} ({t_lbl:.2f}%)")
                        output_lines.append(
                            f"  Incorrect neighbor label: {s['incorrect_neighbor_label']} ({t_nbr:.2f}%)")
                    elif tid == 'F':
                        t_lbl, _ = pct_and_se(s['incorrect_target_label'], t_total)
                        output_lines.append(f"  Incorrect target label: {s['incorrect_target_label']} ({t_lbl:.2f}%)")
                    else:
                        if 'incorrect_target' in s:
                            t_tgt, _ = pct_and_se(s['incorrect_target'], t_total)
                            output_lines.append(f"  Incorrect target: {s['incorrect_target']} ({t_tgt:.2f}%)")

                    if 'incorrect_label' in s:
                        t_lbl, _ = pct_and_se(s['incorrect_label'], t_total)
                        lbl_text = "Incorrect label (CL mode)" if tid == 'C' else "Incorrect label"
                        output_lines.append(f"  {lbl_text}: {s['incorrect_label']} ({t_lbl:.2f}%)")

                    output_lines.extend([
                        f"    - High confidence mistakes: {s['high_conf_mistake']} ({t_high:.2f}%)",
                        f"    - Low confidence mistakes: {s['low_conf_mistake']} ({t_low:.2f}%)",
                    ])

        output_lines.append(separator)
        output_text = "\n".join(output_lines)

        # Print to console
        print("\n" + output_text + "\n")

        # Save to file
        output_file = os.path.join(
            out_dir,
            f"accuracy_{tasks_tag}_{args.ckpt_iter}_{args.num_test_dataset}{temp_suffix}{partial_suffix}.txt" if args.multitasks else f"accuracy_{args.ckpt_iter}_{args.num_of_paths}{temp_suffix}{partial_suffix}.txt"
        )
        with open(output_file, 'w') as f:
            f.write(output_text + "\n")

        print(f"Results saved to {output_file}")
    else:
        print(f"File {file_path} not found.")