@fastino-ai/pioneer-cli 0.2.0 → 0.2.2

package/workspaces/santa-2025/evaluate_submission.py

@@ -0,0 +1,173 @@
+"""
+Evaluate a submission file using the official metric.
+"""
+
+from decimal import Decimal, getcontext
+import pandas as pd
+from shapely import affinity
+from shapely.geometry import Polygon
+from shapely.ops import unary_union
+from shapely.strtree import STRtree
+
+# Decimal precision and scaling factor
+getcontext().prec = 25
+scale_factor = Decimal('1e18')
+
+
+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 evaluate_submission(submission_file):
+    """Evaluate a submission and return the score."""
+    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:
+        if not submission[c].str.startswith('s').all():
+            print(f'Warning: Value(s) in column {c} found without `s` prefix.')
+        submission[c] = submission[c].str[1:]
+
+    # Enforce value limits
+    limit = 100
+    bad_x = (submission['x'].astype(float) < -limit).any() or \
+            (submission['x'].astype(float) > limit).any()
+    bad_y = (submission['y'].astype(float) < -limit).any() or \
+            (submission['y'].astype(float) > limit).any()
+    if bad_x or bad_y:
+        print('Error: x and/or y values outside the bounds of -100 to 100.')
+        return None
+
+    # Grouping puzzles to score
+    submission['tree_count_group'] = submission['id'].str.split('_').str[0]
+
+    total_score = Decimal('0.0')
+    puzzle_scores = []
+    
+    for group, df_group in submission.groupby('tree_count_group'):
+        num_trees = len(df_group)
+
+        # Create tree objects from the submission values
+        placed_trees = []
+        for _, row in df_group.iterrows():
+            placed_trees.append(ChristmasTree(row['x'], row['y'], row['deg']))
+
+        # Check for collisions using neighborhood search
+        all_polygons = [p.polygon for p in placed_trees]
+        r_tree = STRtree(all_polygons)
+
+        # Checking for collisions
+        has_collision = False
+        for i, poly in enumerate(all_polygons):
+            indices = r_tree.query(poly)
+            for index in indices:
+                if index == i:  # don't check against self
+                    continue
+                if poly.intersects(all_polygons[index]) and not poly.touches(all_polygons[index]):
+                    print(f'Error: Overlapping trees in group {group}')
+                    has_collision = True
+                    break
+            if has_collision:
+                break
+        
+        if has_collision:
+            return None
+
+        # Calculate score for the group
+        bounds = unary_union(all_polygons).bounds
+        # Use the largest edge of the bounding rectangle to make a square bounding box
+        side_length_scaled = max(bounds[2] - bounds[0], bounds[3] - bounds[1])
+
+        group_score = (Decimal(side_length_scaled) ** 2) / (scale_factor**2) / Decimal(num_trees)
+        total_score += group_score
+        
+        puzzle_scores.append({
+            'puzzle': group,
+            'num_trees': num_trees,
+            'side_length': float(Decimal(side_length_scaled) / scale_factor),
+            'score': float(group_score)
+        })
+
+    return float(total_score), puzzle_scores
+
+
+def main():
+    """Evaluate the baseline submission."""
+    print("=" * 80)
+    print("Evaluating Baseline Submission")
+    print("=" * 80)
+    
+    result = evaluate_submission('baseline_submission.csv')
+    
+    if result is None:
+        print("\nSubmission is INVALID!")
+        return
+    
+    total_score, puzzle_scores = result
+    
+    print(f"\nTotal Score: {total_score:.6f}")
+    print("\nPuzzle-by-puzzle breakdown (first 20 and last 20):")
+    print("-" * 80)
+    print(f"{'Puzzle':<10} {'Trees':<10} {'Side Length':<15} {'Score':<15}")
+    print("-" * 80)
+    
+    # Show first 20
+    for ps in puzzle_scores[:20]:
+        print(f"{ps['puzzle']:<10} {ps['num_trees']:<10} {ps['side_length']:<15.6f} {ps['score']:<15.6f}")
+    
+    if len(puzzle_scores) > 40:
+        print("...")
+    
+    # Show last 20
+    for ps in puzzle_scores[-20:]:
+        print(f"{ps['puzzle']:<10} {ps['num_trees']:<10} {ps['side_length']:<15.6f} {ps['score']:<15.6f}")
+    
+    print("-" * 80)
+    print(f"\nSubmission is VALID!")
+    print(f"Total Score: {total_score:.6f}")
+    print("=" * 80)
+
+
+if __name__ == "__main__":
+    main()

package/workspaces/santa-2025/explore_competition.py

@@ -0,0 +1,62 @@
+"""
+Santa 2025 Kaggle Competition Explorer
+"""
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+
+# Read sample submission
+df = pd.read_csv('sample_submission.csv')
+
+print("=" * 80)
+print("SANTA 2025 COMPETITION ANALYSIS")
+print("=" * 80)
+
+# Parse IDs to understand structure
+df['puzzle_id'] = df['id'].str.split('_').str[0]
+df['piece_id'] = df['id'].str.split('_').str[1].astype(int)
+
+# Count pieces per puzzle
+pieces_per_puzzle = df.groupby('puzzle_id')['piece_id'].max() + 1
+print(f"\nPuzzle Statistics:")
+print(f"Total number of puzzles: {len(pieces_per_puzzle)}")
+print(f"Min pieces: {pieces_per_puzzle.min()}")
+print(f"Max pieces: {pieces_per_puzzle.max()}")
+print(f"Mean pieces: {pieces_per_puzzle.mean():.2f}")
+
+print(f"\nPieces distribution:")
+print(pieces_per_puzzle.value_counts().sort_index().head(20))
+
+# Parse coordinate values (they start with 's')
+def parse_value(val):
+    """Parse value like 's0.0' or 's90.0' to float"""
+    if isinstance(val, str) and val.startswith('s'):
+        return float(val[1:])
+    return float(val)
+
+df['x_val'] = df['x'].apply(parse_value)
+df['y_val'] = df['y'].apply(parse_value)
+df['deg_val'] = df['deg'].apply(parse_value)
+
+print(f"\nCoordinate ranges:")
+print(f"X: [{df['x_val'].min():.4f}, {df['x_val'].max():.4f}]")
+print(f"Y: [{df['y_val'].min():.4f}, {df['y_val'].max():.4f}]")
+print(f"Rotation (degrees): {df['deg_val'].unique()}")
+
+# Show a sample puzzle
+sample_puzzle = '005'
+puzzle_data = df[df['puzzle_id'] == sample_puzzle]
+print(f"\nSample Puzzle {sample_puzzle}:")
+print(puzzle_data[['id', 'x_val', 'y_val', 'deg_val']].to_string(index=False))
+
+# Try to understand the format better
+print("\n" + "=" * 80)
+print("OBSERVATIONS:")
+print("=" * 80)
+print("1. Format: id, x, y, deg (rotation)")
+print("2. Each puzzle has a different number of pieces")
+print("3. Values are prefixed with 's' (possibly for 'solution' or 'string')")
+print("4. First piece is always at (0.0, 0.0) with 90 degree rotation")
+print("5. This appears to be a 2D packing/placement problem")
+print("\nThe goal is likely to arrange pieces (polygons?) optimally.")
+print("The score might be based on compactness, overlap minimization, or similar metrics.")

package/workspaces/santa-2025/fetch_competition_info.py

@@ -0,0 +1,57 @@
+"""
+Fetch competition information from Kaggle
+"""
+import requests
+from bs4 import BeautifulSoup
+import json
+
+# Try to get competition overview
+url = "https://www.kaggle.com/competitions/santa-2025/overview"
+
+print("Fetching competition information from Kaggle...")
+
+try:
+    response = requests.get(url)
+    if response.status_code == 200:
+        soup = BeautifulSoup(response.text, 'html.parser')
+        
+        # Try to find the main content
+        # Kaggle often has scripts with competition data
+        scripts = soup.find_all('script')
+        
+        print(f"Found {len(scripts)} script tags")
+        
+        # Look for text content in the page
+        content = soup.get_text()
+        
+        # Extract key sections
+        if "Description" in content:
+            print("\nFound description section")
+        if "Evaluation" in content:
+            print("Found evaluation section")
+        if "Prize" in content:
+            print("Found prize section")
+            
+        # Save the raw HTML for inspection
+        with open('competition_page.html', 'w', encoding='utf-8') as f:
+            f.write(response.text)
+        print("\nSaved competition page to competition_page.html")
+        
+    else:
+        print(f"Failed to fetch page: {response.status_code}")
+        
+except Exception as e:
+    print(f"Error: {e}")
+
+# Try the data page as well
+print("\n" + "=" * 80)
+print("Trying data page...")
+data_url = "https://www.kaggle.com/competitions/santa-2025/data"
+try:
+    response = requests.get(data_url)
+    if response.status_code == 200:
+        with open('competition_data_page.html', 'w', encoding='utf-8') as f:
+            f.write(response.text)
+        print("Saved data page to competition_data_page.html")
+except Exception as e:
+    print(f"Error: {e}")

package/workspaces/santa-2025/fix_small_configs_fast.py

@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+"""
+Quick fix for small configurations (n=1-6) - the biggest wins.
+Uses simple, proven arrangements.
+"""
+
+import pandas as pd
+import numpy as np
+from shapely import affinity
+from shapely.geometry import Polygon
+from shapely.ops import unary_union
+
+
+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."""
+    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
+
+
+def optimize_n1():
+    """N=1: Single tree at origin."""
+    # Tree dimensions: width=0.7, height=1.0
+    # At 0° or 90°, bounding box is 0.7 x 1.0
+    return [(0.0, 0.0, 0.0)]
+
+
+def optimize_n2():
+    """N=2: Two trees side-by-side."""
+    # Two trees at 0° separated horizontally
+    return [
+        (-0.36, 0.0, 0.0),
+        (0.36, 0.0, 0.0)
+    ]
+
+
+def optimize_n3():
+    """N=3: Triangular arrangement."""
+    # Three trees in triangle
+    return [
+        (0.0, 0.4, 0.0),
+        (-0.36, -0.2, 0.0),
+        (0.36, -0.2, 0.0)
+    ]
+
+
+def optimize_n4():
+    """N=4: 2x2 grid."""
+    # Four trees in 2x2 grid
+    return [
+        (-0.36, -0.52, 0.0),
+        (0.36, -0.52, 0.0),
+        (-0.36, 0.52, 0.0),
+        (0.36, 0.52, 0.0)
+    ]
+
+
+def optimize_n5():
+    """N=5: One center + 4 around."""
+    # Pentagon-like arrangement
+    return [
+        (0.0, 0.0, 0.0),
+        (-0.5, -0.5, 0.0),
+        (0.5, -0.5, 0.0),
+        (-0.5, 0.5, 0.0),
+        (0.5, 0.5, 0.0)
+    ]
+
+
+def optimize_n6():
+    """N=6: 2x3 grid."""
+    # Six trees in grid
+    return [
+        (-0.36, -0.7, 0.0),
+        (0.36, -0.7, 0.0),
+        (-0.36, 0.0, 0.0),
+        (0.36, 0.0, 0.0),
+        (-0.36, 0.7, 0.0),
+        (0.36, 0.7, 0.0)
+    ]
+
+
+def main():
+    print("=" * 70)
+    print("QUICK FIX: Small Configurations (n=1-6)")
+    print("=" * 70)
+    
+    optimizers = {
+        1: optimize_n1,
+        2: optimize_n2,
+        3: optimize_n3,
+        4: optimize_n4,
+        5: optimize_n5,
+        6: optimize_n6
+    }
+    
+    results = {}
+    total_score = 0
+    
+    for n, optimizer in optimizers.items():
+        config = optimizer()
+        score, side = compute_score(config)
+        results[n] = (config, score, side)
+        total_score += score
+        print(f"n={n}: score={score:.6f}, side={side:.6f}")
+    
+    print("\n" + "=" * 70)
+    print(f"Total score for n=1-6: {total_score:.6f}")
+    print("=" * 70)
+    
+    # Create CSV
+    rows = []
+    for n, (config, score, side) in results.items():
+        for i, (x, y, angle) in enumerate(config):
+            rows.append({
+                'id': f'{n:03d}_{i}',
+                'x': f's{x:.15f}',
+                'y': f's{y:.15f}',
+                'deg': f's{angle:.15f}'
+            })
+    
+    df = pd.DataFrame(rows)
+    output_file = 'optimized_n1_to_n6.csv'
+    df.to_csv(output_file, index=False)
+    print(f"\nSaved to: {output_file}")
+    
+    # Load current best and compare
+    try:
+        current = pd.read_csv('/Users/kz/code/drop/workspace/santa-2025/best_public/submission_best.csv')
+        current['n'] = current['id'].str.split('_').str[0].astype(int)
+        current_small = current[current['n'] <= 6]
+        
+        current_scores = []
+        for n in range(1, 7):
+            group = current_small[current_small['n'] == n]
+            trees = []
+            for _, row in group.iterrows():
+                x = float(row['x'].strip('s'))
+                y = float(row['y'].strip('s'))
+                angle = float(row['deg'].strip('s'))
+                trees.append(create_tree_polygon(x, y, angle))
+            
+            bounds = unary_union(trees).bounds
+            side = max(bounds[2] - bounds[0], bounds[3] - bounds[1])
+            score = side ** 2 / n
+            current_scores.append(score)
+        
+        current_total = sum(current_scores)
+        
+        print("\n" + "=" * 70)
+        print("COMPARISON WITH CURRENT BEST")
+        print("=" * 70)
+        print(f"Current n=1-6 total: {current_total:.6f}")
+        print(f"Optimized n=1-6 total: {total_score:.6f}")
+        print(f"Improvement: {current_total - total_score:.6f} points")
+        print("=" * 70)
+        
+    except Exception as e:
+        print(f"\nCouldn't compare with current: {e}")
+
+
+if __name__ == '__main__':
+    main()

package/workspaces/santa-2025/improved_log.txt

@@ -0,0 +1,48 @@
+================================================================================
+Santa 2025 - Improved Solution
+================================================================================
+
+Trying 5 different random seeds...
+
+Seed 1/5: 42
+  - Testing aligned angles...
+    Score: 176.117711
+  - Testing random angles...
+    Score: 167.870314
+  ✓ New best! (aligned angles)
+  ✓ New best! (random angles)
+
+Seed 2/5: 123
+  - Testing aligned angles...
+    Score: 171.939539
+  - Testing random angles...
+    Score: 169.066398
+
+Seed 3/5: 456
+  - Testing aligned angles...
+    Score: 173.793090
+  - Testing random angles...
+    Score: 163.436976
+  ✓ New best! (random angles)
+
+Seed 4/5: 789
+  - Testing aligned angles...
+    Score: 173.441193
+  - Testing random angles...
+    Score: 164.106464
+
+Seed 5/5: 2024
+  - Testing aligned angles...
+    Score: 176.150290
+  - Testing random angles...
+    Score: 162.382305
+  ✓ New best! (random angles)
+
+================================================================================
+Best score found: 162.382305
+================================================================================
+
+Creating submission file...
+Improved submission saved to improved_submission.csv
+Final score: 162.382305
+================================================================================