fastevolve 0.2.0__py3-none-any.whl

fastevolve/__init__.py

@@ -0,0 +1,11 @@
+from importlib.metadata import PackageNotFoundError, version as _pkg_version
+
+from .config import Config
+from .controller import Controller, RunResult, apply_diff
+
+try:
+    __version__ = _pkg_version("fastevolve")
+except PackageNotFoundError:
+    __version__ = "0.0.0+unknown"
+
+__all__ = ["Config", "Controller", "RunResult", "apply_diff", "__version__"]

fastevolve/config.py

@@ -0,0 +1,14 @@
+from dataclasses import dataclass, field
+from .prompt_sampler.config import PromptConfig
+from .llm_ensemble.config import EnsembleConfig
+from .evaluator.config import EvaluatorConfig
+from .program_database.config import DatabaseConfig
+
+
+@dataclass(kw_only=True)
+class Config:
+    prompt: PromptConfig = field(default_factory=PromptConfig)
+    ensemble: EnsembleConfig = field(default_factory=EnsembleConfig)
+    evaluator: EvaluatorConfig = field(default_factory=EvaluatorConfig)
+    database: DatabaseConfig = field(default_factory=DatabaseConfig)
+    iterations: int = 100

fastevolve/controller.py

@@ -0,0 +1,86 @@
+import re
+from dataclasses import dataclass, field
+from typing import Optional
+
+from rich.progress import (
+    BarColumn, MofNCompleteColumn, Progress, TextColumn,
+    TimeElapsedColumn, TimeRemainingColumn,
+)
+
+from .config import Config
+from .prompt_sampler import PromptSampler, TemplateLibrary
+from .llm_ensemble import LLMEnsemble
+from .evaluator import Evaluator
+from .program_database import ProgramDatabase, Program
+from .telemetry import setup, span, timings, log
+
+
+@dataclass(kw_only=True)
+class RunResult:
+    best: Optional[Program]
+    iterations: int
+    stats: dict = field(default_factory=dict)
+
+
+def apply_diff(parent_program: Program, diff: str) -> Program:
+    m = re.search(r"```(?:python)?\s*\n(.*?)```", diff, re.DOTALL)
+    code = (m.group(1) if m else diff).strip()
+    if not code:
+        code = parent_program.code
+    return Program(code=code, parent_id=parent_program.id, island=parent_program.island,
+                   generation=parent_program.generation + 1)
+
+
+class Controller:
+    def __init__(self, config: Config, *, initial_program: str):
+        setup()
+        self.config = config
+        lib = TemplateLibrary()
+        self.sampler = PromptSampler(config.prompt, library=lib)
+        self.ensemble = LLMEnsemble(config.ensemble, system_prompts=lib.system_prompts)
+        self.evaluator = Evaluator(config.evaluator)
+        self.database = ProgramDatabase(config.database)
+        seed = self.database.seed(initial_program)
+        self.database.add(seed, self.evaluator.execute(seed))
+
+    def run(self) -> RunResult:
+        best: Optional[Program] = None
+        cols = [
+            TextColumn("[bold cyan]evolve[/]"),
+            BarColumn(), MofNCompleteColumn(),
+            TextColumn("[yellow]{task.fields[stage]:>8}[/]"),
+            TextColumn("fit=[green]{task.fields[fit]:.3f}[/]"),
+            TextColumn("best=[magenta]{task.fields[best]:.3f}[/]"),
+            TimeElapsedColumn(), TimeRemainingColumn(),
+        ]
+        with Progress(*cols, transient=False) as prog:
+            task = prog.add_task("run", total=self.config.iterations, stage="init", fit=0.0, best=0.0)
+            for _ in range(self.config.iterations):
+                prog.update(task, stage="sample")
+                with span("sample"):
+                    parent, insp = self.database.sample()
+                prog.update(task, stage="prompt")
+                with span("prompt"):
+                    prompt = self.sampler.build(parent, insp)
+                prog.update(task, stage="generate")
+                with span("generate"):
+                    diff = self.ensemble.generate(prompt)
+                with span("apply"):
+                    child = apply_diff(parent, diff)
+                    child.island = parent.island
+                prog.update(task, stage="evaluate")
+                with span("evaluate"):
+                    result = self.evaluator.execute(child)
+                self.database.add(child, result)
+                if best is None or child.fitness > best.fitness:
+                    best = child
+                prog.update(task, advance=1, fit=child.fitness,
+                            best=best.fitness if best else 0.0)
+        t = timings()
+        log.info("done. population=%d best=%.3f", len(self.database.by_id),
+                 best.fitness if best else 0.0)
+        for name, s in t.items():
+            log.info("[cyan]%-9s[/] n=%-4d total=%6.2fs avg=%.3fs",
+                     name, s["n"], s["total"], s["avg"])
+        return RunResult(best=best, iterations=self.config.iterations,
+                         stats={"population": len(self.database.by_id), "timings": t})

fastevolve/evaluator/__init__.py

@@ -0,0 +1,5 @@
+from .config import EvaluatorConfig
+from .result import EvaluationResult
+from .evaluator import Evaluator
+
+__all__ = ["EvaluatorConfig", "EvaluationResult", "Evaluator"]

fastevolve/evaluator/config.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass, field
+from typing import Callable, List, Tuple
+
+
+@dataclass(kw_only=True)
+class EvaluatorConfig:
+    cascade: List[Tuple[Callable, float]] = field(default_factory=list)
+    timeout: float = 30.0
+    parallelism: int = 1

fastevolve/evaluator/evaluator.py

@@ -0,0 +1,26 @@
+from queue import PriorityQueue
+
+from ..telemetry import log
+from .result import EvaluationResult
+
+
+class Evaluator:
+    def __init__(self, config):
+        self.config = config
+        self.pool: PriorityQueue = PriorityQueue()
+
+    def execute(self, child_program) -> EvaluationResult:
+        result = EvaluationResult()
+        for stage_fn, threshold in self.config.cascade:
+            name = getattr(stage_fn, "__name__", f"stage{len(result.scores)}")
+            try:
+                score = float(stage_fn(child_program))
+            except Exception:
+                log.exception("evaluator stage [yellow]%s[/] raised on program %s", name, child_program.id)
+                return result
+            result.scores[name] = score
+            if score < threshold:
+                return result
+        result.passed = True
+        result.behavior = tuple(max(0.0, min(1.0, v)) for v in result.scores.values())
+        return result

fastevolve/evaluator/result.py

@@ -0,0 +1,13 @@
+from dataclasses import dataclass, field
+
+
+@dataclass(kw_only=True)
+class EvaluationResult:
+    scores: dict = field(default_factory=dict)
+    passed: bool = False
+    behavior: tuple = ()
+    extras: dict = field(default_factory=dict)
+
+    @property
+    def fitness(self) -> float:
+        return sum(self.scores.values()) / max(1, len(self.scores))

fastevolve/llm_ensemble/__init__.py

@@ -0,0 +1,6 @@
+from .config import ModelConfig, EnsembleConfig
+from .base import BaseLLM
+from .ollama import OllamaLLM
+from .ensemble import LLMEnsemble
+
+__all__ = ["ModelConfig", "EnsembleConfig", "BaseLLM", "OllamaLLM", "LLMEnsemble"]

fastevolve/llm_ensemble/base.py

@@ -0,0 +1,6 @@
+from abc import ABC, abstractmethod
+
+
+class BaseLLM(ABC):
+    @abstractmethod
+    def generate(self, prompt: str) -> str: ...

fastevolve/llm_ensemble/config.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass, field
+from typing import List, Literal
+
+
+@dataclass(kw_only=True)
+class ModelConfig:
+    name: str
+    temperature: float = 0.7
+    weight: float = 1.0
+    role: Literal["fast", "deep"] = "fast"
+    num_ctx: int = 4096
+    flash_attention: bool = True
+    options: dict = field(default_factory=dict)
+
+
+@dataclass(kw_only=True)
+class EnsembleConfig:
+    models: List[ModelConfig] = field(default_factory=list)
+    host: str = "http://localhost:11434"
+    timeout: float = 600.0

fastevolve/llm_ensemble/ensemble.py

@@ -0,0 +1,18 @@
+import random
+from .ollama import OllamaLLM
+
+
+class LLMEnsemble:
+    def __init__(self, config, *, system_prompts: dict | None = None):
+        self.config = config
+        sp = system_prompts or {}
+        self.llms = [OllamaLLM(m, host=config.host, timeout=config.timeout,
+                               system_prompt=sp.get(m.name)) for m in config.models]
+        if not self.llms:
+            raise ValueError("EnsembleConfig.models is empty")
+
+    def select_model(self) -> OllamaLLM:
+        return random.choices(self.llms, weights=[m.cfg.weight for m in self.llms], k=1)[0]
+
+    def generate(self, prompt: str) -> str:
+        return self.select_model().generate(prompt)

fastevolve/llm_ensemble/ollama.py

@@ -0,0 +1,45 @@
+from ollama import Client, ResponseError
+
+from ..telemetry import log
+from .base import BaseLLM
+
+
+class OllamaLLM(BaseLLM):
+    def __init__(self, model_config, *, host: str = "http://localhost:11434", timeout: float = 600.0, system_prompt: str | None = None):
+        self.cfg = model_config
+        self.system_prompt = system_prompt
+        self.client = Client(host=host, timeout=timeout)
+        self._ensure_model()
+
+    def _ensure_model(self):
+        try:
+            self.client.show(self.cfg.name)
+        except ResponseError:
+            log.info("[ollama] pulling [bold]%s[/]...", self.cfg.name)
+            self.client.pull(self.cfg.name)
+
+    def generate(self, prompt: str) -> str:
+        try:
+            return self._generate(prompt)
+        except Exception:
+            log.exception("ollama generate failed for model=%s", self.cfg.name)
+            raise
+
+    def _options(self) -> dict:
+        opts = {
+            "temperature": self.cfg.temperature,
+            "num_ctx": self.cfg.num_ctx,
+            "flash_attn": self.cfg.flash_attention,
+        }
+        opts.update(self.cfg.options)
+        return opts
+
+    def _generate(self, prompt: str) -> str:
+        resp = self.client.generate(
+            model=self.cfg.name,
+            prompt=prompt,
+            system=self.system_prompt,
+            options=self._options(),
+            stream=False,
+        )
+        return resp.response

fastevolve/program_database/__init__.py

@@ -0,0 +1,6 @@
+from .config import DatabaseConfig
+from .program import Program
+from .embedder import CodeEmbedder
+from .database import ProgramDatabase
+
+__all__ = ["DatabaseConfig", "Program", "CodeEmbedder", "ProgramDatabase"]

fastevolve/program_database/config.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+
+
+@dataclass(kw_only=True)
+class DatabaseConfig:
+    num_islands: int = 4
+    cell_bins: int = 10
+    top_k: int = 16
+    num_inspirations: int = 3
+    migration_size: int = 8
+    migration_every: int = 25

fastevolve/program_database/database.py

@@ -0,0 +1,57 @@
+import heapq
+import random
+from collections import deque
+from .program import Program
+from .embedder import CodeEmbedder
+
+
+class ProgramDatabase:
+    def __init__(self, config):
+        self.config = config
+        self.islands: list[dict] = [dict() for _ in range(config.num_islands)]
+        self.by_id: dict[int, Program] = {}
+        self.heap: list[tuple[float, int]] = []
+        self.migrations = [deque(maxlen=config.migration_size) for _ in range(config.num_islands)]
+        self.embedder = CodeEmbedder()
+        self.step = 0
+
+    def _cell(self, behavior):
+        if not behavior:
+            return (0,)
+        return tuple(min(self.config.cell_bins - 1, int(b * self.config.cell_bins)) for b in behavior)
+
+    def seed(self, code: str, *, island: int = 0) -> Program:
+        p = Program(code=code, island=island)
+        self.by_id[p.id] = p
+        self.islands[island][("seed", p.id)] = p
+        heapq.heappush(self.heap, (0.0, p.id))
+        self.embedder.add(self.embedder.embed(p), p.id)
+        return p
+
+    def add(self, child_program: Program, results):
+        child_program.fitness = results.fitness
+        child_program.behavior = results.behavior
+        cell = self._cell(results.behavior)
+        grid = self.islands[child_program.island % self.config.num_islands]
+        if cell not in grid or grid[cell].fitness < child_program.fitness:
+            grid[cell] = child_program
+        self.by_id[child_program.id] = child_program
+        heapq.heappush(self.heap, (-child_program.fitness, child_program.id))
+        self.embedder.add(self.embedder.embed(child_program), child_program.id)
+        self.step += 1
+        if self.step % self.config.migration_every == 0:
+            self._migrate()
+
+    def _migrate(self):
+        n = self.config.num_islands
+        for i, grid in enumerate(self.islands):
+            if grid:
+                self.migrations[(i + 1) % n].append(max(grid.values(), key=lambda p: p.fitness))
+
+    def sample(self):
+        top = heapq.nsmallest(self.config.top_k, self.heap)
+        live = [(f, pid) for f, pid in top if pid in self.by_id] or [(0.0, next(iter(self.by_id)))]
+        parent = self.by_id[random.choice(live)[1]]
+        ids = self.embedder.nearest(self.embedder.embed(parent), k=self.config.num_inspirations + 1)
+        insp = [self.by_id[i] for i in ids if i != parent.id and i in self.by_id][: self.config.num_inspirations]
+        return parent, insp

fastevolve/program_database/embedder.py

@@ -0,0 +1,25 @@
+import math
+import re
+from collections import Counter
+
+
+class CodeEmbedder:
+    def __init__(self):
+        self.index: list[tuple[Counter, int]] = []
+
+    def embed(self, program) -> Counter:
+        return Counter(re.findall(r"\w+", program.code))
+
+    def add(self, vector: Counter, program_id: int):
+        self.index.append((vector, program_id))
+
+    @staticmethod
+    def _cos(a: Counter, b: Counter) -> float:
+        num = sum(a[t] * b[t] for t in set(a) & set(b))
+        na = math.sqrt(sum(v * v for v in a.values()))
+        nb = math.sqrt(sum(v * v for v in b.values()))
+        return num / (na * nb) if na and nb else 0.0
+
+    def nearest(self, vector: Counter, *, k: int) -> list[int]:
+        scored = sorted(((self._cos(vector, v), pid) for v, pid in self.index), reverse=True)
+        return [pid for _, pid in scored[:k]]

fastevolve/program_database/program.py

@@ -0,0 +1,16 @@
+import itertools
+from dataclasses import dataclass, field
+from typing import Optional, Tuple
+
+_ids = itertools.count()
+
+
+@dataclass
+class Program:
+    code: str
+    id: int = field(default_factory=lambda: next(_ids), kw_only=True)
+    parent_id: Optional[int] = field(default=None, kw_only=True)
+    fitness: float = field(default=0.0, kw_only=True)
+    behavior: Tuple = field(default=(), kw_only=True)
+    island: int = field(default=0, kw_only=True)
+    generation: int = field(default=0, kw_only=True)

fastevolve/prompt_sampler/__init__.py

@@ -0,0 +1,5 @@
+from .config import PromptConfig
+from .template_library import TemplateLibrary
+from .sampler import PromptSampler
+
+__all__ = ["PromptConfig", "TemplateLibrary", "PromptSampler"]

fastevolve/prompt_sampler/config.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass, field
+
+
+@dataclass(kw_only=True)
+class PromptConfig:
+    template: str = "default"
+    num_inspirations: int = 3
+    temperature: float = 0.7
+    system_prompts: dict = field(default_factory=dict)

fastevolve/prompt_sampler/sampler.py

@@ -0,0 +1,12 @@
+from .template_library import TemplateLibrary
+
+
+class PromptSampler:
+    def __init__(self, config, *, library: TemplateLibrary | None = None):
+        self.config = config
+        self.library = library or TemplateLibrary()
+        self.library.system_prompts.update(config.system_prompts)
+
+    def build(self, parent_program, inspirations):
+        insp = "\n---\n".join(p.code for p in inspirations) or "(none)"
+        return self.library.render(self.config.template, parent=parent_program.code, inspirations=insp)

fastevolve/prompt_sampler/template_library.py

@@ -0,0 +1,25 @@
+from pathlib import Path
+
+DEFAULT = """You are evolving a Python program. Improve the parent program.
+
+# Parent
+{parent}
+
+# Inspirations
+{inspirations}
+
+Return ONLY the full replacement Python code (no prose, no fences)."""
+
+
+class TemplateLibrary:
+    def __init__(self):
+        self.templates = {"default": DEFAULT}
+        self.system_prompts: dict[str, str] = {}
+
+    def load(self, path):
+        for f in Path(path).glob("*.txt"):
+            self.templates[f.stem] = f.read_text(encoding="utf-8")
+
+    def get(self, name): return self.templates[name]
+
+    def render(self, name, **vars): return self.templates[name].format(**vars)

fastevolve/telemetry.py

@@ -0,0 +1,36 @@
+import logging
+import os
+import time
+from collections import defaultdict
+from contextlib import contextmanager
+
+from rich.logging import RichHandler
+
+log = logging.getLogger("fastevolve")
+_TIMINGS: dict[str, list[float]] = defaultdict(list)
+
+
+def setup() -> None:
+    if logging.getLogger().handlers:
+        return
+    level = logging.WARNING if os.getenv("FASTEVOLVE_QUIET") else logging.INFO
+    logging.basicConfig(
+        level=level, format="%(message)s", datefmt="[%X]",
+        handlers=[RichHandler(rich_tracebacks=True, show_path=False, markup=True)],
+    )
+
+
+@contextmanager
+def span(name: str):
+    t = time.perf_counter()
+    try:
+        yield
+    except Exception:
+        log.exception("[red]%s failed after %.2fs[/]", name, time.perf_counter() - t)
+        raise
+    finally:
+        _TIMINGS[name].append(time.perf_counter() - t)
+
+
+def timings() -> dict[str, dict[str, float]]:
+    return {k: {"n": len(v), "total": sum(v), "avg": sum(v) / len(v)} for k, v in _TIMINGS.items()}

fastevolve-0.2.0.dist-info/METADATA

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: fastevolve
+Version: 0.2.0
+Summary: Minimal open-source AlphaEvolve: LLM-driven program evolution with MAP-Elites islands, cascade evaluation, and a local Ollama ensemble.
+Project-URL: Homepage, https://github.com/tiagomonteiro/alpha_evolve_open_souce_version
+Project-URL: Issues, https://github.com/tiagomonteiro/alpha_evolve_open_souce_version/issues
+Author-email: Tiago Monteiro <monteiro.t@northeastern.edu>
+License: MIT
+Keywords: alphaevolve,evolutionary-search,llm,map-elites,ollama,program-synthesis
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.12
+Requires-Dist: ollama>=0.4.0
+Requires-Dist: rich>=13.7
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# fastevolve
+
+Minimal open-source AlphaEvolve: LLM-driven program evolution with MAP-Elites islands, cascade evaluation, and a local Ollama ensemble.
+
+## Install
+
+```bash
+uv sync
+```
+
+## Run the demo
+
+Start Ollama and pull the model first:
+
+```bash
+ollama serve
+ollama pull gemma3:e4b
+```
+
+Then:
+
+```bash
+uv run python main.py
+```

fastevolve-0.2.0.dist-info/RECORD

@@ -0,0 +1,26 @@
+fastevolve/__init__.py,sha256=EPOCJKvRBM-PnX-m7sdDH1nQgTqyYPtdScoJXD4ZoqM,355
+fastevolve/config.py,sha256=fqq7HZM_Nh1or1MR-ajJpJY_FQqiqnFGjJfNhunilBQ,575
+fastevolve/controller.py,sha256=Z6qXAffclGTicUqsxrGb2rY5rzTjCKaU3AqvYE9UecE,3653
+fastevolve/telemetry.py,sha256=EpThR2zHUxqdJ835v-JjxkY2Xas1G80SvsaM4bMQVrw,997
+fastevolve/evaluator/__init__.py,sha256=IvelEVdP8TDKu1vc7H35R24H2hRXfgua94HxEH-NaJ0,170
+fastevolve/evaluator/config.py,sha256=QBeOeIb8nuBoLmc6LXh3leIbnb99drF_imZPKw7fDaU,255
+fastevolve/evaluator/evaluator.py,sha256=xL1B8GIBQwHDpNhyKWSagcS1uAXo7mH8FBja45K3SeA,941
+fastevolve/evaluator/result.py,sha256=R416-7j2x0rPhdFKte6qSe6D1POCI9vTsw7qSJPb65c,351
+fastevolve/llm_ensemble/__init__.py,sha256=-1CQiNjkp45ni5F2eVO-EXBxRiB11ktpI2xqzOyYL00,222
+fastevolve/llm_ensemble/base.py,sha256=958WidTEGAx6eDx3rAY3Gqp1qKj6K2NINlTUKPmtWWI,126
+fastevolve/llm_ensemble/config.py,sha256=8BazEWwbmZguxnYT6jC3TfLoPLdk7zqNwqUZGfYQsm0,512
+fastevolve/llm_ensemble/ensemble.py,sha256=UhLMa_08SObEMYVkEUFF5v3d-uJJZ3Sj54NJtmgvsDE,680
+fastevolve/llm_ensemble/ollama.py,sha256=PKfpfnwN8ebsiMNUYQDHqTEnwSWcYEuoRdaimCxqMSk,1422
+fastevolve/program_database/__init__.py,sha256=3Pgkj5AssBXy7iOMvpxKUViP1K5oWdxl09LjcvqQdyg,213
+fastevolve/program_database/config.py,sha256=v8bhchs8BbDoa6LE67Vsc4MmyI_5ktfGl3fO6udcquQ,240
+fastevolve/program_database/database.py,sha256=Py_o9yuSGSGTZBOT74SmoB5w6NyrG9sSrgoPTJRUfsU,2438
+fastevolve/program_database/embedder.py,sha256=uQGTNzNw8-npumjLVNEKxjI4sFmWVmkEjN2CiXAry6w,842
+fastevolve/program_database/program.py,sha256=KJYSmu84LmIbXXjB0p1KENU-0fFA7iWXynXpSx_T47g,506
+fastevolve/prompt_sampler/__init__.py,sha256=-YtYT7Rc7GwT0uTxNKwEte3XhaWwc-kZagGYhrCWGrw,178
+fastevolve/prompt_sampler/config.py,sha256=6PRqLdzzTDcP7rkWxk4UYvP0tGI9xQdntpYAJWTNM1k,232
+fastevolve/prompt_sampler/sampler.py,sha256=rQQrsQE_4Ba_zSmEI18hH-gJon0OM2JooPHuyrVGmfc,519
+fastevolve/prompt_sampler/template_library.py,sha256=EvPyZlK8LURQ9qngMQBYdBl43WWL0PN3PHhSduYy_fM,639
+fastevolve-0.2.0.dist-info/METADATA,sha256=UoDHGoR7ACe7FF-l1yVmDaTgEmbW2Wg9vLcWNSdgyvY,1354
+fastevolve-0.2.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+fastevolve-0.2.0.dist-info/entry_points.txt,sha256=IpEsShMkKymR93wiyRle9nSCY03yiQPWshXWUsSE-pY,46
+fastevolve-0.2.0.dist-info/RECORD,,

fastevolve-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

fastevolve-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fastevolve-demo = main:main