File size: 4,581 Bytes
5e4510c | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 | # Configuration for fft_convolution task - Optimized Gemini Flash 2.5
# Achieved 1.64x AlgoTune Score with these settings
# General settings
max_iterations: 100
checkpoint_interval: 10
log_level: "INFO"
random_seed: 42
diff_based_evolution: true # Best for Gemini models
max_code_length: 20000 # Increased from 10000 for deeper exploration
# LLM Configuration
llm:
api_base: "https://openrouter.ai/api/v1"
models:
- name: "google/gemini-2.5-flash"
weight: 0.8
- name: "google/gemini-2.5-pro"
weight: 0.2
temperature: 0.4 # Optimal (better than 0.2, 0.6, 0.8)
max_tokens: 128000 # Increased from 16000 for much richer context
timeout: 150
retries: 3
# Prompt Configuration - Optimal settings
prompt:
system_message: |
SETTING:
You're an autonomous programmer tasked with solving a specific problem. You are to use the commands defined below to accomplish this task. Every message you send incurs a cost—you will be informed of your usage and remaining budget by the system.
You will be evaluated based on the best-performing piece of code you produce, even if the final code doesn't work or compile (as long as it worked at some point and achieved a score, you will be eligible).
Apart from the default Python packages, you have access to the following additional packages:
- cryptography
- cvxpy
- cython
- dace
- dask
- diffrax
- ecos
- faiss-cpu
- hdbscan
- highspy
- jax
- networkx
- numba
- numpy
- ortools
- pandas
- pot
- psutil
- pulp
- pyomo
- python-sat
- pythran
- scikit-learn
- scipy
- sympy
- torch
Your primary objective is to optimize the `solve` function to run as as fast as possible, while returning the optimal solution.
You will receive better scores the quicker your solution runs, and you will be penalized for exceeding the time limit or returning non-optimal solutions.
Below you find the description of the task you will have to solve. Read it carefully and understand what the problem is and what your solver should do.
You are an expert programmer specializing in signal_processing algorithms. Your task is to improve the fft_convolution algorithm implementation with baseline comparison.
The problem description is:
FFT Convolution Task:
Given two signals x and y, the task is to compute their convolution using the Fast Fourier Transform (FFT) approach. The convolution of x and y is defined as:
z[n] = sum_k x[k] * y[n-k]
Using the FFT approach exploits the fact that convolution in the time domain is equivalent to multiplication in the frequency domain, which provides a more efficient computation for large signals.
Focus on improving the solve method to correctly handle the input format and produce valid solutions efficiently. Your solution will be compared against the reference AlgoTune baseline implementation to measure speedup and correctness.
PERFORMANCE OPTIMIZATION OPPORTUNITIES:
You have access to high-performance libraries that can provide significant speedups:
• **JAX** - JIT compilation for numerical computations
• **Numba** - Alternative JIT compilation, often simpler to use
• **scipy optimizations** - Direct BLAS/LAPACK access and specialized algorithms
Many scipy functions have optimized implementations worth exploring
• **Vectorization** - Look for opportunities to replace loops with array operations
num_top_programs: 5 # Increased from 3-5 for richer learning context
num_diverse_programs: 5 # Increased from 2 for more diverse exploration
include_artifacts: true # +20.7% improvement
# Database Configuration
database:
population_size: 1000
archive_size: 100
num_islands: 4
# Selection parameters - Optimal ratios
elite_selection_ratio: 0.1 # 10% elite
exploration_ratio: 0.3 # 30% exploration
exploitation_ratio: 0.6 # 60% exploitation
# NO feature_dimensions - let it use defaults based on evaluator metrics
feature_bins: 10
# Migration parameters
migration_interval: 20
migration_rate: 0.1 # Better than 0.2
# Evaluator Configuration
evaluator:
timeout: 200
max_retries: 3
# Cascade evaluation
cascade_evaluation: true
cascade_thresholds: [0.5, 0.8]
# Parallel evaluations
parallel_evaluations: 4
# AlgoTune task-specific configuration
algotune:
num_trials: 5
data_size: 125
timeout: 300
num_runs: 3
warmup_runs: 1
|