asi-evolve 0.1.0__py3-none-any.whl

asi_evolve/__init__.py

@@ -0,0 +1,22 @@
+"""asi-evolve — Pythonic wrapper around the ASI-Evolve evolutionary-search framework.
+
+Drop a problem, an initial candidate, and an evaluator script. asi-evolve runs the
+autonomous loop until it finds a better solution. CLI or `--serve` web dashboard.
+
+Vendored upstream: GAIR-NLP/ASI-Evolve @ fb8a67e (Apache 2.0).
+This wrapper layer: MIT (see LICENSE).
+"""
+
+__version__ = "0.1.0"
+
+# IMPORTANT: do not eagerly import the vendored package here — it pulls in
+# faiss-cpu, sentence-transformers, torch, numpy and takes ~20s to load.
+# The `Pipeline` re-export is lazy so `asi-run --help` and pure-Python
+# tooling stay fast.
+def __getattr__(name):
+    if name == "Pipeline":
+        from asi_evolve._vendor.ASI_Evolve.pipeline import Pipeline as _Pipeline
+        return _Pipeline
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+__all__ = ["Pipeline", "__version__"]

asi_evolve/_vendor/ASI_Evolve/__init__.py

@@ -0,0 +1,3 @@
+"""ASI-Evolve package."""
+
+__version__ = "0.1.0"

asi_evolve/_vendor/ASI_Evolve/cognition/__init__.py

@@ -0,0 +1,7 @@
+"""Cognition storage and retrieval utilities."""
+
+from .cognition import Cognition
+
+__all__ = [
+    "Cognition",
+]

asi_evolve/_vendor/ASI_Evolve/cognition/cognition.py

@@ -0,0 +1,180 @@
+"""Cognition-store implementation."""
+
+import json
+import uuid
+from pathlib import Path
+from threading import RLock
+from typing import Dict, List, Optional, Tuple
+
+from ..utils.structures import CognitionItem
+from ..database.faiss_index import FAISSIndex
+from ..database.embedding import EmbeddingService
+
+
+class Cognition:
+    """
+    Persistent cognition store with embedding-based retrieval.
+
+    Features:
+    - CRUD operations for cognition items
+    - Semantic retrieval through FAISS
+    - Local persistence to disk
+    """
+
+    def __init__(
+        self,
+        storage_dir: Path,
+        embedding_model: str = "sentence-transformers/all-MiniLM-L6-v2",
+        embedding_dim: int = 384,
+        retrieval_top_k: int = 5,
+        score_threshold: float = 0.5,
+        faiss_index_type: str = "IP",
+    ):
+        self.storage_dir = Path(storage_dir)
+        self.storage_dir.mkdir(parents=True, exist_ok=True)
+
+        self.lock = RLock()
+        self.retrieval_top_k = retrieval_top_k
+        self.score_threshold = score_threshold
+
+        self.items: Dict[str, CognitionItem] = {}
+
+        self.embedding = EmbeddingService(model_name=embedding_model)
+
+        self.faiss = FAISSIndex(
+            dimension=embedding_dim,
+            index_type=faiss_index_type,
+            storage_path=self.storage_dir / "faiss",
+        )
+
+        self.str_to_int: Dict[str, int] = {}
+        self.int_to_str: Dict[int, str] = {}
+        self.next_int_id = 0
+
+        self._load()
+
+    def _get_int_id(self, str_id: str) -> int:
+        if str_id not in self.str_to_int:
+            self.str_to_int[str_id] = self.next_int_id
+            self.int_to_str[self.next_int_id] = str_id
+            self.next_int_id += 1
+        return self.str_to_int[str_id]
+
+    def add(self, item: CognitionItem) -> str:
+        with self.lock:
+            if not item.id:
+                item.id = str(uuid.uuid4())
+
+            self.items[item.id] = item
+
+            if item.content:
+                int_id = self._get_int_id(item.id)
+                vector = self.embedding.encode(item.content)
+                self.faiss.add(int_id, vector)
+
+            self._save()
+            return item.id
+
+    def add_batch(self, items: List[CognitionItem]) -> List[str]:
+        return [self.add(item) for item in items]
+
+    def remove(self, item_id: str) -> bool:
+        with self.lock:
+            if item_id not in self.items:
+                return False
+
+            del self.items[item_id]
+
+            if item_id in self.str_to_int:
+                int_id = self.str_to_int.pop(item_id)
+                self.int_to_str.pop(int_id, None)
+                self.faiss.remove(int_id)
+
+            self._save()
+            return True
+
+    def remove_batch(self, item_ids: List[str]) -> int:
+        return sum(1 for iid in item_ids if self.remove(iid))
+
+    def get(self, item_id: str) -> Optional[CognitionItem]:
+        return self.items.get(item_id)
+
+    def get_all(self) -> List[CognitionItem]:
+        return list(self.items.values())
+
+    def retrieve(
+        self,
+        query: str,
+        top_k: Optional[int] = None,
+        score_threshold: Optional[float] = None,
+    ) -> List[Tuple[CognitionItem, float]]:
+        top_k = top_k or self.retrieval_top_k
+        score_threshold = score_threshold if score_threshold is not None else self.score_threshold
+
+        query_vector = self.embedding.encode(query)
+        results = self.faiss.search(query_vector, top_k, score_threshold)
+
+        items_with_scores = []
+        for int_id, score in results:
+            str_id = self.int_to_str.get(int_id)
+            if str_id:
+                item = self.items.get(str_id)
+                if item:
+                    items_with_scores.append((item, score))
+
+        return items_with_scores
+
+    def search(self, query: str, top_k: Optional[int] = None) -> List[CognitionItem]:
+        results = self.retrieve(query, top_k)
+        return [item for item, _ in results]
+
+    def reset(self):
+        with self.lock:
+            self.items.clear()
+            self.str_to_int.clear()
+            self.int_to_str.clear()
+            self.next_int_id = 0
+            self.faiss.reset()
+
+            data_file = self.storage_dir / "cognition.json"
+            if data_file.exists():
+                data_file.unlink()
+
+    def _save(self):
+        data_file = self.storage_dir / "cognition.json"
+
+        data = {
+            "items": {k: v.to_dict() for k, v in self.items.items()},
+            "str_to_int": self.str_to_int,
+            "int_to_str": {str(k): v for k, v in self.int_to_str.items()},
+            "next_int_id": self.next_int_id,
+        }
+
+        with open(data_file, "w", encoding="utf-8") as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+
+        self.faiss.save()
+
+    def _load(self):
+        data_file = self.storage_dir / "cognition.json"
+
+        if not data_file.exists():
+            return
+
+        with open(data_file, "r", encoding="utf-8") as f:
+            data = json.load(f)
+
+        for item_id, item_data in data.get("items", {}).items():
+            item = CognitionItem.from_dict(item_data)
+            self.items[item_id] = item
+
+        self.str_to_int = data.get("str_to_int", {})
+        self.int_to_str = {int(k): v for k, v in data.get("int_to_str", {}).items()}
+        self.next_int_id = data.get("next_int_id", 0)
+
+    @property
+    def size(self) -> int:
+        return len(self.items)
+
+    def __len__(self) -> int:
+        return self.size

asi_evolve/_vendor/ASI_Evolve/config.yaml

@@ -0,0 +1,119 @@
+# Evolve Framework Configuration (Default Template)
+# ================================================
+# This file defines repository-wide defaults.
+# Priority: explicit config file > experiment config > repository config.
+
+# Experiment name
+experiment_name: "default"
+
+# API configuration
+# In practice, experiment-level config files usually override these values.
+api:
+  provider: "openai"  # Any OpenAI-compatible endpoint
+  base_url: "your_base_url"
+  api_key: "your_api_key"
+  model: "your_model"
+  temperature: 0
+  top_p: 0.8
+  max_tokens: 16384
+  seed: 42
+  timeout: 300
+  retry_times: 3
+  retry_delay: 5
+
+# Logging configuration
+logging:
+  level: "INFO"
+  console: true
+  wandb:
+    enabled: true
+    offline: false  # Use `wandb sync` later when running offline
+    project: "evolve"
+    entity: ""
+
+# Pipeline configuration
+pipeline:
+  # Agent toggles
+  agents:
+    manager: false
+    researcher: true
+    engineer: true
+    analyzer: true
+
+  # Researcher configuration
+  researcher:
+    # When enabled, the researcher edits a sampled parent via SEARCH/REPLACE diffs.
+    diff_based_evolution: true
+
+    # Regex used to parse diff-based edits.
+    diff_pattern: "<<<<<<< SEARCH\\n(.*?)=======\\n(.*?)>>>>>>> REPLACE"
+
+    # Maximum generated code length.
+    max_code_length: 10000
+
+  # Retry counts per agent
+  max_retries:
+    researcher: 3
+    engineer: 2
+    analyzer: 2
+
+  # Engineer timeout in seconds
+  engineer_timeout: 1800
+
+  # Parallel execution
+  parallel:
+    num_workers: 1
+    # Suggested settings:
+    # - 1: sequential execution, best for debugging
+    # - 2-4: practical parallelism for production runs
+    # - >4: requires enough API quota and compute resources
+
+  # Number of historical nodes sampled per step
+  sample_n: 3
+
+  # Optional LLM-based judge
+  # final_score = (1 - judge_ratio) * eval_score + judge_ratio * judge_score
+  judge:
+    enabled: false
+    ratio: 0.2
+    # Provide `judge.jinja2` in the experiment prompts directory when enabled.
+
+# Cognition configuration
+cognition:
+  # Path relative to the experiment directory
+  storage_dir: "cognition_data"
+  embedding:
+    model: "sentence-transformers/all-MiniLM-L6-v2"
+    dimension: 384
+  faiss:
+    index_type: "IP"
+  retrieval:
+    top_k: 3
+    score_threshold: 0.3
+  # Reserved for future web-search support
+  web_search:
+    enabled: false
+
+# Database configuration
+database:
+  # Path relative to the experiment directory
+  storage_dir: "database_data"
+  # Limit database size. When full, the lowest-scoring node is removed.
+  max_size: null
+  embedding:
+    model: "sentence-transformers/all-MiniLM-L6-v2"
+    dimension: 384
+  # Sampling algorithm
+  sampling:
+    algorithm: "ucb1"
+    ucb1_c: 1.414
+    # Island-sampler parameters
+    island:
+      num_islands: 5
+      migration_interval: 10
+      migration_rate: 0.1
+      exploration_ratio: 0.2
+      exploitation_ratio: 0.3
+      # The remaining probability mass is used for weighted sampling.
+  faiss:
+    index_type: "IP"

asi_evolve/_vendor/ASI_Evolve/database/__init__.py

@@ -0,0 +1,21 @@
+"""Experiment database and sampling utilities."""
+
+from .database import Database
+from .algorithms import (
+    get_sampler,
+    BaseSampler,
+    UCB1Sampler,
+    RandomSampler,
+    GreedySampler,
+    IslandSampler,
+)
+
+__all__ = [
+    "Database",
+    "get_sampler",
+    "BaseSampler",
+    "UCB1Sampler",
+    "RandomSampler",
+    "GreedySampler",
+    "IslandSampler",
+]

asi_evolve/_vendor/ASI_Evolve/database/algorithms/__init__.py

@@ -0,0 +1,17 @@
+"""Sampling algorithms used by the experiment database."""
+
+from .base import BaseSampler
+from .random import RandomSampler
+from .greedy import GreedySampler
+from .ucb1 import UCB1Sampler
+from .island import IslandSampler
+from .factory import get_sampler
+
+__all__ = [
+    "BaseSampler",
+    "RandomSampler",
+    "GreedySampler",
+    "UCB1Sampler",
+    "IslandSampler",
+    "get_sampler",
+]

asi_evolve/_vendor/ASI_Evolve/database/algorithms/base.py

@@ -0,0 +1,43 @@
+"""Base interface for node samplers."""
+
+from abc import ABC, abstractmethod
+from typing import List, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..utils.structures import Node
+
+
+class BaseSampler(ABC):
+    """Abstract sampler used by the experiment database."""
+
+    @abstractmethod
+    def sample(self, nodes: List["Node"], n: int) -> List["Node"]:
+        """
+        Sample a subset of nodes.
+
+        Args:
+            nodes: All candidate nodes.
+            n: Number of nodes to return.
+
+        Returns:
+            A list of sampled nodes.
+        """
+        pass
+
+    def on_node_added(self, node: "Node") -> None:
+        """
+        Hook called when a node is added.
+
+        Args:
+            node: The newly added node.
+        """
+        pass
+
+    def on_node_removed(self, node: "Node") -> None:
+        """
+        Hook called when a node is removed.
+
+        Args:
+            node: The removed node.
+        """
+        pass

asi_evolve/_vendor/ASI_Evolve/database/algorithms/factory.py

@@ -0,0 +1,41 @@
+"""Factory for sampler implementations."""
+
+from typing import Any
+
+from .base import BaseSampler
+from .random import RandomSampler
+from .greedy import GreedySampler
+from .ucb1 import UCB1Sampler
+from .island import IslandSampler
+
+
+def get_sampler(algorithm: str, **kwargs) -> BaseSampler:
+    """
+    Construct a sampler by name.
+
+    Args:
+        algorithm: Algorithm name (`ucb1`, `random`, `greedy`, or `island`).
+        **kwargs: Algorithm-specific parameters.
+
+    Returns:
+        A sampler instance.
+
+    Raises:
+        ValueError: If the algorithm name is unknown.
+    """
+    kwargs = {k: v for k, v in kwargs.items() if v is not None}
+
+    samplers: dict[str, type[BaseSampler]] = {
+        "ucb1": UCB1Sampler,
+        "random": RandomSampler,
+        "greedy": GreedySampler,
+        "island": IslandSampler,
+    }
+
+    if algorithm not in samplers:
+        raise ValueError(
+            f"Unknown sampling algorithm: {algorithm}. "
+            f"Available: {list(samplers.keys())}"
+        )
+
+    return samplers[algorithm](**kwargs)

asi_evolve/_vendor/ASI_Evolve/database/algorithms/greedy.py

@@ -0,0 +1,18 @@
+"""Greedy sampling strategy."""
+
+from typing import List, TYPE_CHECKING
+
+from .base import BaseSampler
+
+if TYPE_CHECKING:
+    from ...utils.structures import Node
+
+
+class GreedySampler(BaseSampler):
+    """Return the highest-scoring nodes first."""
+
+    def sample(self, nodes: List["Node"], n: int) -> List["Node"]:
+        if not nodes:
+            return []
+        sorted_nodes = sorted(nodes, key=lambda x: x.score, reverse=True)
+        return sorted_nodes[:n]