@fastino-ai/pioneer-cli 0.2.0 → 0.2.1

package/workspaces/santa-2025/ultra_optimizer.py

@@ -0,0 +1,267 @@
+#!/usr/bin/env python3
+"""
+Ultra Optimizer - Try EVERYTHING to beat 70.926
+
+Strategies:
+1. Complete rebuilds for worst configs
+2. Multiple random seeds
+3. Different packing patterns (grid, hex, spiral)
+4. Aggressive parameter sweeps
+5. Hybrid approaches
+"""
+
+import numpy as np
+import pandas as pd
+from shapely import affinity
+from shapely.geometry import Polygon
+from shapely.ops import unary_union
+from shapely.strtree import STRtree
+import random
+import math
+import multiprocessing as mp
+from functools import partial
+
+def create_tree_polygon(x, y, angle):
+    """Create tree polygon."""
+    trunk_w, trunk_h = 0.15, 0.2
+    base_w, mid_w, top_w = 0.7, 0.4, 0.25
+    tip_y, tier_1_y, tier_2_y, base_y = 0.8, 0.5, 0.25, 0.0
+    trunk_bottom_y = -trunk_h
+
+    coords = [
+        (0.0, tip_y), (top_w/2, tier_1_y), (top_w/4, tier_1_y),
+        (mid_w/2, tier_2_y), (mid_w/4, tier_2_y), (base_w/2, base_y),
+        (trunk_w/2, base_y), (trunk_w/2, trunk_bottom_y),
+        (-trunk_w/2, trunk_bottom_y), (-trunk_w/2, base_y),
+        (-base_w/2, base_y), (-mid_w/4, tier_2_y), (-mid_w/2, tier_2_y),
+        (-top_w/4, tier_1_y), (-top_w/2, tier_1_y),
+    ]
+    poly = Polygon(coords)
+    rotated = affinity.rotate(poly, angle, origin=(0, 0))
+    return affinity.translate(rotated, xoff=x, yoff=y)
+
+
+def compute_score(config):
+    """Compute score for configuration."""
+    if not config:
+        return float('inf'), float('inf'), []
+    trees = [create_tree_polygon(x, y, a) for x, y, a in config]
+    bounds = unary_union(trees).bounds
+    side = max(bounds[2] - bounds[0], bounds[3] - bounds[1])
+    return side ** 2 / len(config), side, trees
+
+
+def check_valid(config):
+    """Check if configuration has no overlaps."""
+    trees = [create_tree_polygon(x, y, a) for x, y, a in config]
+    tree_index = STRtree(trees)
+    for i, tree in enumerate(trees):
+        possible = tree_index.query(tree)
+        for j in possible:
+            if i < j:
+                if trees[i].intersects(trees[j]) and not trees[i].touches(trees[j]):
+                    return False
+    return True
+
+
+def grid_packing(n, angle=0, spacing=0.75):
+    """Create grid-based packing."""
+    cols = math.ceil(math.sqrt(n))
+    config = []
+    for i in range(n):
+        row = i // cols
+        col = i % cols
+        x = (col - cols/2) * spacing
+        y = (row - cols/2) * spacing
+        config.append((x, y, angle))
+    return config
+
+
+def hex_packing(n, angle=0):
+    """Create hexagonal packing."""
+    config = [(0, 0, angle)]
+    if n == 1:
+        return config
+    
+    radius = 0.8
+    ring = 1
+    placed = 1
+    
+    while placed < n:
+        positions_in_ring = 6 * ring
+        for i in range(positions_in_ring):
+            if placed >= n:
+                break
+            theta = 2 * math.pi * i / positions_in_ring
+            x = radius * ring * math.cos(theta)
+            y = radius * ring * math.sin(theta)
+            config.append((x, y, angle))
+            placed += 1
+        ring += 1
+    
+    return config
+
+
+def spiral_packing(n, angle=0):
+    """Create spiral packing."""
+    config = [(0, 0, angle)]
+    if n == 1:
+        return config
+    
+    radius = 0.5
+    theta = 0
+    for i in range(1, n):
+        theta += 0.5
+        radius += 0.03
+        x = radius * math.cos(theta)
+        y = radius * math.sin(theta)
+        config.append((x, y, angle))
+    
+    return config
+
+
+def random_jiggle(config, iterations=1000, step_size=0.01):
+    """Apply random perturbations to improve packing."""
+    best_config = list(config)
+    best_score, _, _ = compute_score(best_config)
+    
+    for _ in range(iterations):
+        test_config = [
+            (x + random.gauss(0, step_size), 
+             y + random.gauss(0, step_size),
+             (a + random.gauss(0, 2)) % 360)
+            for x, y, a in best_config
+        ]
+        
+        if check_valid(test_config):
+            score, _, _ = compute_score(test_config)
+            if score < best_score:
+                best_score = score
+                best_config = test_config
+    
+    return best_config, best_score
+
+
+def optimize_single_n(args):
+    """Optimize a single configuration n with multiple strategies."""
+    n, current_config, current_score = args
+    
+    best_config = list(current_config)
+    best_score = current_score
+    
+    strategies = [
+        ('grid_0', lambda: grid_packing(n, angle=0, spacing=0.75)),
+        ('grid_90', lambda: grid_packing(n, angle=90, spacing=0.75)),
+        ('grid_tight', lambda: grid_packing(n, angle=0, spacing=0.72)),
+        ('hex_0', lambda: hex_packing(n, angle=0)),
+        ('hex_90', lambda: hex_packing(n, angle=90)),
+        ('spiral', lambda: spiral_packing(n, angle=0)),
+    ]
+    
+    for name, strategy_fn in strategies:
+        try:
+            config = strategy_fn()
+            if check_valid(config):
+                # Apply jiggling
+                config, score = random_jiggle(config, iterations=500)
+                if score < best_score:
+                    best_score = score
+                    best_config = config
+                    print(f"  n={n}: {name} improved to {score:.6f}")
+        except:
+            pass
+    
+    return n, best_config, best_score
+
+
+def main():
+    print("=" * 70)
+    print("ULTRA OPTIMIZER - Trying All Strategies")
+    print("=" * 70)
+    
+    # Load current best
+    print("\nLoading current best...")
+    df = pd.read_csv('/Users/kz/code/drop/workspace/santa-2025/best_public/submission_best.csv')
+    df['n'] = df['id'].str.split('_').str[0].astype(int)
+    
+    configs = {}
+    current_scores = {}
+    for n in range(1, 201):
+        group = df[df['n'] == n]
+        config = []
+        for _, row in group.iterrows():
+            x = float(row['x'].strip('s'))
+            y = float(row['y'].strip('s'))
+            angle = float(row['deg'].strip('s'))
+            config.append((x, y, angle))
+        configs[n] = config
+        score, _, _ = compute_score(config)
+        current_scores[n] = score
+    
+    initial_total = sum(current_scores.values())
+    print(f"Initial total score: {initial_total:.6f}")
+    
+    # Focus on worst 50 configurations
+    sorted_configs = sorted(current_scores.items(), key=lambda x: x[1], reverse=True)
+    worst_n = [n for n, _ in sorted_configs[:50]]
+    
+    print(f"\nOptimizing worst 50 configurations: {worst_n[:10]}...")
+    
+    # Prepare arguments
+    args = [(n, configs[n], current_scores[n]) for n in worst_n]
+    
+    # Process in parallel
+    print("\nRunning optimizations...")
+    improvements = []
+    
+    for arg in args:
+        n, new_config, new_score = optimize_single_n(arg)
+        old_score = current_scores[n]
+        if new_score < old_score:
+            improvement = old_score - new_score
+            improvements.append((n, improvement))
+            configs[n] = new_config
+            print(f"✓ n={n}: {old_score:.6f} → {new_score:.6f} (Δ={improvement:.6f})")
+    
+    # Calculate final score
+    final_total = sum(compute_score(configs[n])[0] for n in range(1, 201))
+    total_improvement = initial_total - final_total
+    
+    print("\n" + "=" * 70)
+    print("FINAL RESULTS")
+    print("=" * 70)
+    print(f"Initial score: {initial_total:.6f}")
+    print(f"Final score:   {final_total:.6f}")
+    print(f"Improvement:   {total_improvement:.6f}")
+    
+    if improvements:
+        print(f"\nConfigurations improved: {len(improvements)}")
+        improvements.sort(key=lambda x: x[1], reverse=True)
+        print("Top 10 improvements:")
+        for n, imp in improvements[:10]:
+            print(f"  n={n:3d}: {imp:.6f}")
+    
+    # Save result
+    print("\nSaving optimized submission...")
+    rows = []
+    for n in range(1, 201):
+        for i, (x, y, angle) in enumerate(configs[n]):
+            rows.append({
+                'id': f'{n:03d}_{i}',
+                'x': f's{x:.15f}',
+                'y': f's{y:.15f}',
+                'deg': f's{angle:.15f}'
+            })
+    
+    df_out = pd.DataFrame(rows)
+    output_file = f'ultra_optimized_score{final_total:.2f}.csv'
+    df_out.to_csv(output_file, index=False)
+    
+    print(f"Saved to: {output_file}")
+    print("=" * 70)
+
+
+if __name__ == '__main__':
+    random.seed(42)
+    np.random.seed(42)
+    main()

package/workspaces/santa-2025/visualize.py

@@ -0,0 +1,166 @@
+"""
+Visualize tree arrangements from submission.
+"""
+
+from decimal import Decimal, getcontext
+import pandas as pd
+import matplotlib.pyplot as plt
+from matplotlib.patches import Rectangle
+from shapely import affinity
+from shapely.geometry import Polygon
+from shapely.ops import unary_union
+import sys
+
+# Decimal precision and scaling factor
+getcontext().prec = 25
+scale_factor = Decimal('1e15')
+
+
+class ChristmasTree:
+    """Represents a single, rotatable Christmas tree of a fixed size."""
+
+    def __init__(self, center_x='0', center_y='0', angle='0'):
+        """Initializes the Christmas tree with a specific position and rotation."""
+        self.center_x = Decimal(center_x)
+        self.center_y = Decimal(center_y)
+        self.angle = Decimal(angle)
+
+        trunk_w = Decimal('0.15')
+        trunk_h = Decimal('0.2')
+        base_w = Decimal('0.7')
+        mid_w = Decimal('0.4')
+        top_w = Decimal('0.25')
+        tip_y = Decimal('0.8')
+        tier_1_y = Decimal('0.5')
+        tier_2_y = Decimal('0.25')
+        base_y = Decimal('0.0')
+        trunk_bottom_y = -trunk_h
+
+        initial_polygon = Polygon([
+            (Decimal('0.0') * scale_factor, tip_y * scale_factor),
+            (top_w / Decimal('2') * scale_factor, tier_1_y * scale_factor),
+            (top_w / Decimal('4') * scale_factor, tier_1_y * scale_factor),
+            (mid_w / Decimal('2') * scale_factor, tier_2_y * scale_factor),
+            (mid_w / Decimal('4') * scale_factor, tier_2_y * scale_factor),
+            (base_w / Decimal('2') * scale_factor, base_y * scale_factor),
+            (trunk_w / Decimal('2') * scale_factor, base_y * scale_factor),
+            (trunk_w / Decimal('2') * scale_factor, trunk_bottom_y * scale_factor),
+            (-(trunk_w / Decimal('2')) * scale_factor, trunk_bottom_y * scale_factor),
+            (-(trunk_w / Decimal('2')) * scale_factor, base_y * scale_factor),
+            (-(base_w / Decimal('2')) * scale_factor, base_y * scale_factor),
+            (-(mid_w / Decimal('4')) * scale_factor, tier_2_y * scale_factor),
+            (-(mid_w / Decimal('2')) * scale_factor, tier_2_y * scale_factor),
+            (-(top_w / Decimal('4')) * scale_factor, tier_1_y * scale_factor),
+            (-(top_w / Decimal('2')) * scale_factor, tier_1_y * scale_factor),
+        ])
+        rotated = affinity.rotate(initial_polygon, float(self.angle), origin=(0, 0))
+        self.polygon = affinity.translate(rotated,
+                                          xoff=float(self.center_x * scale_factor),
+                                          yoff=float(self.center_y * scale_factor))
+
+
+def plot_puzzle(submission_file, puzzle_num):
+    """Plot a specific puzzle."""
+    submission = pd.read_csv(submission_file)
+    
+    # Remove the leading 's' from submissions
+    data_cols = ['x', 'y', 'deg']
+    submission = submission.astype(str)
+    for c in data_cols:
+        submission[c] = submission[c].str[1:]
+    
+    # Get specific puzzle
+    puzzle_id = f'{puzzle_num:03d}'
+    puzzle_data = submission[submission['id'].str.startswith(puzzle_id + '_')]
+    
+    if len(puzzle_data) == 0:
+        print(f"Puzzle {puzzle_id} not found!")
+        return
+    
+    # Create trees
+    placed_trees = []
+    for _, row in puzzle_data.iterrows():
+        placed_trees.append(ChristmasTree(row['x'], row['y'], row['deg']))
+    
+    # Calculate bounding square
+    all_polygons = [t.polygon for t in placed_trees]
+    bounds = unary_union(all_polygons).bounds
+    
+    minx = Decimal(bounds[0]) / scale_factor
+    miny = Decimal(bounds[1]) / scale_factor
+    maxx = Decimal(bounds[2]) / scale_factor
+    maxy = Decimal(bounds[3]) / scale_factor
+    
+    width = maxx - minx
+    height = maxy - miny
+    side_length = max(width, height)
+    
+    # Plot
+    fig, ax = plt.subplots(figsize=(10, 10))
+    colors = plt.cm.viridis([i / len(placed_trees) for i in range(len(placed_trees))])
+    
+    for i, tree in enumerate(placed_trees):
+        # Rescale for plotting
+        x_scaled, y_scaled = tree.polygon.exterior.xy
+        x = [Decimal(val) / scale_factor for val in x_scaled]
+        y = [Decimal(val) / scale_factor for val in y_scaled]
+        ax.plot(x, y, color=colors[i], linewidth=1.5)
+        ax.fill(x, y, alpha=0.6, color=colors[i])
+    
+    # Draw bounding square
+    square_x = minx if width >= height else minx - (side_length - width) / 2
+    square_y = miny if height >= width else miny - (side_length - height) / 2
+    bounding_square = Rectangle(
+        (float(square_x), float(square_y)),
+        float(side_length),
+        float(side_length),
+        fill=False,
+        edgecolor='red',
+        linewidth=3,
+        linestyle='--',
+        label='Bounding Square'
+    )
+    ax.add_patch(bounding_square)
+    
+    # Set plot limits
+    padding = float(side_length) * 0.1
+    ax.set_xlim(float(square_x) - padding, float(square_x + side_length) + padding)
+    ax.set_ylim(float(square_y) - padding, float(square_y + side_length) + padding)
+    ax.set_aspect('equal', adjustable='box')
+    ax.grid(True, alpha=0.3)
+    
+    # Calculate score
+    score = float(side_length) ** 2 / len(placed_trees)
+    
+    ax.set_title(f'Puzzle {puzzle_id}: {len(placed_trees)} Trees\n' +
+                 f'Side Length: {float(side_length):.4f}, Score: {score:.4f}',
+                 fontsize=14, fontweight='bold')
+    ax.legend()
+    
+    plt.tight_layout()
+    plt.savefig(f'puzzle_{puzzle_id}.png', dpi=150, bbox_inches='tight')
+    print(f"Saved puzzle_{puzzle_id}.png")
+    plt.close()
+
+
+def main():
+    """Visualize selected puzzles."""
+    submission_file = 'baseline_submission.csv'
+    
+    if len(sys.argv) > 1:
+        submission_file = sys.argv[1]
+    
+    print(f"Visualizing puzzles from {submission_file}")
+    
+    # Plot puzzles with different sizes
+    puzzles_to_plot = [10, 20, 50, 100, 150, 200]
+    
+    for puzzle_num in puzzles_to_plot:
+        print(f"Plotting puzzle {puzzle_num}...")
+        plot_puzzle(submission_file, puzzle_num)
+    
+    print("\nDone! Generated visualizations for puzzles:", puzzles_to_plot)
+
+
+if __name__ == "__main__":
+    main()