Add ARC-AGI Interactive Puzzle Viewer with Git LFS for dataset files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.json filter=lfs diff=lfs merge=lfs -text

arc-prize-2025-dataset/arc-agi_evaluation_challenges.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bee6bffea3dc7bcc8fabb5b8e947e1a4950a5087b988f41eee3e57053d2053ad
+size 9190477

arc-prize-2025-dataset/arc-agi_evaluation_solutions.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:84be4f4f39b79e82c36d565fc878830988b094917f052ee7069aef30b33ca8f1
+size 223838

arc-prize-2025-dataset/arc-agi_test_challenges.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:232264c58f825ee77327dcfc9f4e5cb2f83b8d997eb69032be1bf2205bbe1a83
+size 1015295

arc-prize-2025-dataset/arc-agi_training_challenges.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0a8511f909adc0380fc9b33b42c166c1d2e2de06ead60bee65b153b8c772d916
+size 37629560

arc-prize-2025-dataset/arc-agi_training_solutions.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9f07a38bd25af5e83aa5bf85c5cb1a1fefdb30f6a755256fa65429e697ca97f9
+size 658743

arc-prize-2025-dataset/sample_submission.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6b372dce41ad86a941ccdcbebb2b1926fd4f011d77c824ff421d77730f169a9a
+size 19936

arc_puzzle_gradio_viewer.py

@@ -0,0 +1,516 @@
+import gradio as gr
+import json
+import numpy as np
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import os
+from typing import List, Dict, Any, Tuple
+import hashlib
+
+# Constants
+ARC_COLORS = [
+    '#000000',  # 0: black
+    '#0074D9',  # 1: blue
+    '#FFDC00',  # 2: yellow
+    '#FF4136',  # 3: red
+    '#2ECC40',  # 4: green
+    '#AAAAAA',  # 5: gray
+    '#F012BE',  # 6: magenta
+    '#FF851B',  # 7: orange
+    '#7FDBFF',  # 8: light blue
+    '#870C25',  # 9: dark red
+]
+
+# UI Constants
+BASE_FIGURE_SIZE = 250
+MAX_FIGURE_SIZE = 400
+GRID_LINE_WIDTH = 2
+GRID_LINE_COLOR = "white"
+DEFAULT_FONT_SIZE = 14
+LARGE_FONT_SIZE = 16
+SMALL_FONT_SIZE = 12
+PLACEHOLDER_COLOR = "#7f8c8d"
+TITLE_COLOR = "#2c3e50"
+
+# Layout Constants
+SUBPLOT_HORIZONTAL_SPACING = 0.05
+SUBPLOT_VERTICAL_SPACING = 0.1
+FIGURE_MARGIN = dict(l=10, r=10, t=40, b=10)
+SUBPLOT_MARGIN = dict(l=20, r=20, t=60, b=20)
+HEIGHT_PER_ROW_TRAIN = 200
+HEIGHT_PER_ROW_TEST = 300
+MIN_FIGURE_HEIGHT = 400
+
+# Dataset files
+DATASET_FILES = [
+    'arc-prize-2025-dataset/arc-agi_training_challenges.json',
+    'arc-prize-2025-dataset/arc-agi_evaluation_challenges.json'
+]
+
+# Global cache
+PUZZLE_CACHE = None
+FIGURE_CACHE = {}
+
+# Header HTML
+HEADER_HTML = """
+<div style="text-align: center; padding: 15px; background: linear-gradient(90deg, #74b9ff, #0984e3); border-radius: 8px; margin-bottom: 15px;">
+    <h1 style="color: white; margin: 0; font-size: 1.8em;">🧩 ARC-AGI Interactive Puzzle Viewer</h1>
+    <p style="color: white; margin: 5px 0 0 0; font-size: 1em;">Explore ARC-AGI challenges with interactive hover-enabled grids</p>
+</div>
+"""
+
+CSS_STYLES = """
+.gradio-container {
+    max-width: none !important;
+}
+.plot-container {
+    overflow: auto !important;
+}
+"""
+
+def load_puzzles() -> Dict[str, Any]:
+    """Load puzzles from dataset files with caching."""
+    global PUZZLE_CACHE
+    
+    if PUZZLE_CACHE is not None:
+        return PUZZLE_CACHE
+    
+    puzzles = {}
+    print("🔄 Loading puzzles from dataset...")
+    
+    for file in DATASET_FILES:
+        if os.path.exists(file):
+            try:
+                with open(file, 'r') as f:
+                    data = json.load(f)
+                    puzzles.update(data)
+                print(f"✅ Loaded {len(data)} puzzles from {file}")
+            except Exception as e:
+                print(f"❌ Error loading {file}: {e}")
+    
+    PUZZLE_CACHE = puzzles
+    print(f"🎯 Total puzzles cached: {len(puzzles)}")
+    return puzzles
+
+def create_grid_hash(grid: List[List[int]]) -> str:
+    """Create a unique hash for a grid to use as cache key."""
+    return hashlib.md5(str(grid).encode()).hexdigest()
+
+def create_hover_text(grid: np.ndarray) -> List[List[str]]:
+    """Create hover text for grid cells."""
+    hover_text = []
+    for i in range(grid.shape[0]):
+        hover_row = []
+        for j in range(grid.shape[1]):
+            hover_row.append(f"Row: {i}<br>Col: {j}<br>Value: {grid[i][j]}")
+        hover_text.append(hover_row)
+    return hover_text
+
+def add_grid_lines(fig: go.Figure, grid_shape: Tuple[int, int], subplot_row: int = None, subplot_col: int = None):
+    """Add white grid lines to a figure or subplot."""
+    rows, cols = grid_shape
+    
+    # Add horizontal lines
+    for i in range(rows + 1):
+        fig.add_shape(
+            type="line",
+            x0=-0.5, x1=cols-0.5, y0=i-0.5, y1=i-0.5,
+            line=dict(color=GRID_LINE_COLOR, width=GRID_LINE_WIDTH),
+            row=subplot_row, col=subplot_col
+        )
+    
+    # Add vertical lines
+    for j in range(cols + 1):
+        fig.add_shape(
+            type="line",
+            x0=j-0.5, x1=j-0.5, y0=-0.5, y1=rows-0.5,
+            line=dict(color=GRID_LINE_COLOR, width=GRID_LINE_WIDTH),
+            row=subplot_row, col=subplot_col
+        )
+
+def create_heatmap_trace(grid: np.ndarray) -> go.Heatmap:
+    """Create a heatmap trace for a grid."""
+    colorscale = [[i/9, color] for i, color in enumerate(ARC_COLORS)]
+    hover_text = create_hover_text(grid)
+    
+    return go.Heatmap(
+        z=grid,
+        colorscale=colorscale,
+        showscale=False,
+        hovertemplate='%{text}<extra></extra>',
+        text=hover_text,
+        zmin=0,
+        zmax=9,
+        hoverongaps=False
+    )
+
+def create_placeholder_figure(text: str, title: str = "", height: int = 300, width: int = 300) -> go.Figure:
+    """Create a placeholder figure with text annotation."""
+    fig = go.Figure()
+    fig.add_annotation(
+        text=text,
+        x=0.5, y=0.5,
+        showarrow=False,
+        font=dict(size=DEFAULT_FONT_SIZE, color=PLACEHOLDER_COLOR)
+    )
+    fig.update_layout(
+        title=dict(text=title, font=dict(size=DEFAULT_FONT_SIZE, color=TITLE_COLOR)) if title else None,
+        xaxis=dict(visible=False),
+        yaxis=dict(visible=False),
+        height=height,
+        width=width,
+        margin=FIGURE_MARGIN,
+        paper_bgcolor="white",
+        plot_bgcolor="white"
+    )
+    return fig
+
+def calculate_figure_dimensions(grid_shape: Tuple[int, int]) -> Tuple[int, int]:
+    """Calculate optimal figure dimensions based on grid shape."""
+    rows, cols = grid_shape
+    if rows == 0 or cols == 0:
+        return BASE_FIGURE_SIZE, BASE_FIGURE_SIZE
+    
+    aspect_ratio = cols / rows
+    
+    if aspect_ratio > 1:
+        # Wide grid
+        fig_width = min(BASE_FIGURE_SIZE * aspect_ratio, MAX_FIGURE_SIZE)
+        fig_height = BASE_FIGURE_SIZE
+    else:
+        # Tall grid
+        fig_width = BASE_FIGURE_SIZE
+        fig_height = min(BASE_FIGURE_SIZE / aspect_ratio, MAX_FIGURE_SIZE)
+    
+    return int(fig_width), int(fig_height)
+
+def create_grid_figure(grid: List[List[int]], title: str = "Grid") -> go.Figure:
+    """Create an interactive Plotly heatmap for a grid with hover functionality."""
+    if not grid or len(grid) == 0:
+        return create_placeholder_figure("Empty Grid", title)
+    
+    # Create cache key
+    grid_hash = create_grid_hash(grid)
+    cache_key = f"{grid_hash}_{title}"
+    
+    if cache_key in FIGURE_CACHE:
+        cached_fig = FIGURE_CACHE[cache_key]
+        cached_fig.update_layout(title=dict(text=title, font=dict(size=DEFAULT_FONT_SIZE, color=TITLE_COLOR)))
+        return cached_fig
+    
+    grid_array = np.array(grid)
+    fig_width, fig_height = calculate_figure_dimensions(grid_array.shape)
+    
+    fig = go.Figure(data=create_heatmap_trace(grid_array))
+    add_grid_lines(fig, grid_array.shape)
+    
+    fig.update_layout(
+        title=dict(text=title, font=dict(size=DEFAULT_FONT_SIZE, color=TITLE_COLOR)),
+        xaxis=dict(visible=False, range=[-0.5, grid_array.shape[1]-0.5]),
+        yaxis=dict(visible=False, autorange="reversed", range=[-0.5, grid_array.shape[0]-0.5]),
+        height=fig_height,
+        width=fig_width,
+        margin=FIGURE_MARGIN,
+        showlegend=False,
+        paper_bgcolor="white",
+        plot_bgcolor="white"
+    )
+    
+    # Cache the figure
+    FIGURE_CACHE[cache_key] = go.Figure(fig)
+    return fig
+
+def create_unknown_output_figure() -> go.Figure:
+    """Create a clean, simple figure for unknown output."""
+    fig = go.Figure()
+    
+    # Simple dashed border rectangle
+    fig.add_shape(
+        type="rect",
+        x0=0.1, y0=0.15, x1=0.9, y1=0.85,
+        line=dict(color=PLACEHOLDER_COLOR, width=2, dash="dash"),
+        fillcolor="rgba(248, 249, 250, 0.1)"
+    )
+    
+    # Red question mark
+    fig.add_annotation(
+        text="?", 
+        x=0.5, y=0.6, 
+        showarrow=False, 
+        font=dict(size=60, color="#e74c3c", family="Arial Black, Arial, sans-serif")
+    )
+    
+    # "Output Unknown" text
+    fig.add_annotation(
+        text="Output Unknown", 
+        x=0.5, y=0.35, 
+        showarrow=False, 
+        font=dict(size=LARGE_FONT_SIZE, color=PLACEHOLDER_COLOR, family="Arial, sans-serif")
+    )
+    
+    fig.update_layout(
+        title=dict(text="Output", font=dict(size=DEFAULT_FONT_SIZE, color=TITLE_COLOR)),
+        xaxis=dict(visible=False, range=[0, 1]),
+        yaxis=dict(visible=False, range=[0, 1]),
+        height=300,
+        width=300,
+        margin=FIGURE_MARGIN,
+        paper_bgcolor="white",
+        plot_bgcolor="white"
+    )
+    
+    return fig
+
+def update_subplot_layout(fig: go.Figure, total_subplots: int, cols: int):
+    """Update layout for all subplots in a figure."""
+    for i in range(1, total_subplots + 1):
+        row_idx = (i - 1) // cols + 1
+        col_idx = (i - 1) % cols + 1
+        fig.update_xaxes(visible=False, row=row_idx, col=col_idx)
+        fig.update_yaxes(visible=False, autorange="reversed", row=row_idx, col=col_idx)
+
+def create_combined_figure(examples: List[Dict], section_title: str, example_type: str) -> go.Figure:
+    """Create a combined figure showing all examples in a section."""
+    if not examples:
+        return go.Figure()
+    
+    # Calculate subplot layout
+    n_examples = len(examples)
+    total_subplots = n_examples * 2  # Each example has input + output
+    
+    # Layout preference based on example type
+    cols = min(2 if example_type == "test" else 4, total_subplots)
+    rows = ((total_subplots - 1) // cols) + 1
+    
+    # Create subplot titles
+    subplot_titles = []
+    for i, example in enumerate(examples):
+        subplot_titles.extend([
+            f"{example_type.title()} {i+1} - Input",
+            f"{example_type.title()} {i+1} - Output"
+        ])
+    
+    fig = make_subplots(
+        rows=rows, 
+        cols=cols,
+        subplot_titles=subplot_titles,
+        horizontal_spacing=SUBPLOT_HORIZONTAL_SPACING,
+        vertical_spacing=SUBPLOT_VERTICAL_SPACING
+    )
+    
+    plot_idx = 1
+    for i, example in enumerate(examples):
+        row_idx = (plot_idx - 1) // cols + 1
+        col_idx = (plot_idx - 1) % cols + 1
+        
+        # Add input subplot
+        input_grid = np.array(example['input']) if example['input'] else np.array([[]])
+        if input_grid.size > 0 and input_grid.ndim == 2:
+            fig.add_trace(create_heatmap_trace(input_grid), row=row_idx, col=col_idx)
+            add_grid_lines(fig, input_grid.shape, row_idx, col_idx)
+        plot_idx += 1
+        
+        # Add output subplot
+        row_idx = (plot_idx - 1) // cols + 1
+        col_idx = (plot_idx - 1) % cols + 1
+        
+        if 'output' in example and example['output']:
+            output_grid = np.array(example['output'])
+            fig.add_trace(create_heatmap_trace(output_grid), row=row_idx, col=col_idx)
+            add_grid_lines(fig, output_grid.shape, row_idx, col_idx)
+        else:
+            # Add placeholder for unknown output
+            fig.add_annotation(
+                text="❓<br>Unknown",
+                x=0.5, y=0.5,
+                showarrow=False,
+                font=dict(size=SMALL_FONT_SIZE, color=PLACEHOLDER_COLOR),
+                xref=f"x{plot_idx}",
+                yref=f"y{plot_idx}"
+            )
+        plot_idx += 1
+    
+    # Update layout
+    height_per_row = HEIGHT_PER_ROW_TEST if example_type == "test" else HEIGHT_PER_ROW_TRAIN
+    
+    fig.update_layout(
+        title=dict(
+            text=section_title, 
+            font=dict(size=LARGE_FONT_SIZE, color=TITLE_COLOR),
+            x=0.5
+        ),
+        height=max(MIN_FIGURE_HEIGHT, rows * height_per_row),
+        margin=SUBPLOT_MARGIN,
+        paper_bgcolor="white",
+        plot_bgcolor="white"
+    )
+    
+    update_subplot_layout(fig, plot_idx - 1, cols)
+    return fig
+
+def format_puzzle_option(puzzle_id: str, puzzle_data: Dict) -> str:
+    """Format puzzle option for dropdown."""
+    train_count = len(puzzle_data.get('train', []))
+    test_count = len(puzzle_data.get('test', []))
+    return f"{puzzle_id} - {train_count} training, {test_count} test examples"
+
+def parse_puzzle_id(puzzle_selection: str) -> str:
+    """Extract puzzle ID from dropdown selection."""
+    return puzzle_selection.split(' - ')[0] if puzzle_selection else ""
+
+def calculate_puzzle_metadata(examples: List[Dict]) -> Tuple[int, List[str], List[str]]:
+    """Calculate metadata for puzzle examples."""
+    total_cells = 0
+    input_sizes = []
+    output_sizes = []
+    
+    for example in examples:
+        if example.get('input'):
+            input_grid = example['input']
+            h, w = len(input_grid), len(input_grid[0]) if input_grid else 0
+            input_sizes.append(f"{h}×{w}")
+            total_cells += h * w
+            
+        if example.get('output'):
+            output_grid = example['output']
+            h, w = len(output_grid), len(output_grid[0]) if output_grid else 0
+            output_sizes.append(f"{h}×{w}")
+            total_cells += h * w
+    
+    return total_cells, input_sizes, output_sizes
+
+def get_complexity_rating(max_cells: int) -> str:
+    """Get complexity rating based on maximum cells."""
+    if max_cells <= 25:
+        return "🟢 Simple"
+    elif max_cells <= 100:
+        return "🟡 Medium"
+    else:
+        return "🔴 Complex"
+
+def get_puzzle_list() -> List[str]:
+    """Get list of available puzzles for dropdown."""
+    puzzles = load_puzzles()
+    if not puzzles:
+        return []
+    
+    puzzle_options = [format_puzzle_option(pid, data) for pid, data in puzzles.items()]
+    return sorted(puzzle_options)
+
+def display_puzzle_examples(puzzle_selection: str) -> Tuple[go.Figure, go.Figure, str]:
+    """Display all examples for a selected puzzle with interactive plots."""
+    if not puzzle_selection or puzzle_selection == "Select a puzzle...":
+        empty_fig = create_placeholder_figure("Select a puzzle to view its examples", height=300)
+        return empty_fig, empty_fig, "Select a puzzle to view its examples"
+    
+    puzzle_id = parse_puzzle_id(puzzle_selection)
+    puzzles = load_puzzles()
+    
+    if puzzle_id not in puzzles:
+        return go.Figure(), go.Figure(), "Puzzle not found"
+    
+    puzzle = puzzles[puzzle_id]
+    train_examples = puzzle.get('train', [])
+    test_examples = puzzle.get('test', [])
+    
+    # Calculate puzzle metadata
+    all_examples = train_examples + test_examples
+    total_cells, input_sizes, output_sizes = calculate_puzzle_metadata(all_examples)
+    
+    # Find unique grid sizes and complexity
+    all_sizes = input_sizes + output_sizes
+    unique_sizes = list(set(all_sizes))
+    
+    info_text = f"**🎯 Puzzle ID:** `{puzzle_id}`\n\n"
+    info_text += f"**📊 Structure:**\n"
+    info_text += f"• Training Examples: {len(train_examples)}\n"
+    info_text += f"• Test Examples: {len(test_examples)}\n"
+    info_text += f"• Total Grids: {len(train_examples) * 2 + len(test_examples)}\n"
+    info_text += f"• Total Cells: {total_cells:,}\n\n"
+    
+    if unique_sizes:
+        info_text += f"**📐 Grid Dimensions:**\n"
+        sorted_sizes = sorted(unique_sizes, key=lambda x: int(x.split('×')[0]) * int(x.split('×')[1]))
+        info_text += f"• Sizes Found: {', '.join(sorted_sizes)}\n"
+        
+        # Calculate complexity
+        max_cells = max([int(size.split('×')[0]) * int(size.split('×')[1]) for size in unique_sizes])
+        complexity = get_complexity_rating(max_cells)
+        info_text += f"• Complexity: {complexity} (max {max_cells} cells)\n\n"
+    
+    info_text += "💡 **Tip:** Hover over grid cells to see their coordinates and values!"
+    
+    # Create combined figures
+    train_fig = create_combined_figure(train_examples, "📚 Training Examples", "train") if train_examples else go.Figure()
+    test_fig = create_combined_figure(test_examples, "🧪 Test Examples", "test") if test_examples else go.Figure()
+    
+    return train_fig, test_fig, info_text
+
+def create_interface() -> gr.Blocks:
+    """Create the Gradio interface."""
+    puzzle_options = get_puzzle_list()
+    
+    with gr.Blocks(
+        title="🧩 ARC-AGI Interactive Puzzle Viewer", 
+        theme=gr.themes.Soft(),
+        css=CSS_STYLES
+    ) as interface:
+        
+        gr.HTML(HEADER_HTML)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                puzzle_dropdown = gr.Dropdown(
+                    choices=["Select a puzzle..."] + puzzle_options,
+                    value="Select a puzzle...",
+                    label="🎯 Select a Puzzle",
+                    info=f"Choose from {len(puzzle_options)} available puzzles"
+                )
+                
+                puzzle_info = gr.Markdown(
+                    value="Select a puzzle to view its details and examples.",
+                    label="📊 Puzzle Information"
+                )
+            
+            with gr.Column(scale=2):
+                train_plot = gr.Plot(
+                    label="📚 Training Examples",
+                    container=True
+                )
+                
+                test_plot = gr.Plot(
+                    label="🧪 Test Examples", 
+                    container=True
+                )
+        
+        # Set up the callback
+        puzzle_dropdown.change(
+            fn=display_puzzle_examples,
+            inputs=[puzzle_dropdown],
+            outputs=[train_plot, test_plot, puzzle_info]
+        )
+    
+    return interface
+
+def main():
+    """Main function to run the Gradio app."""
+    print("🚀 Starting ARC-AGI Interactive Puzzle Viewer...")
+    print("📍 Dataset location: arc-prize-2025-dataset/")
+    
+    # Pre-load puzzles
+    puzzles = load_puzzles()
+    print(f"✅ Ready with {len(puzzles)} puzzles!")
+    
+    # Create and launch interface
+    interface = create_interface()
+    
+    print("🌐 Launching Gradio interface...")
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        show_error=True,
+        share=False
+    )
+
+if __name__ == "__main__":
+    main()