synth-ai 0.2.14__py3-none-any.whl → 0.4.4__py3-none-any.whl

synth_ai/api/train/config_finder.py

@@ -1,228 +0,0 @@
-from __future__ import annotations
-
-import json
-import os
-from collections.abc import Iterable
-from dataclasses import dataclass
-from pathlib import Path
-
-import click
-
-from .utils import REPO_ROOT, load_toml, preview_json
-
-_SKIP_DIRS = {".git", "__pycache__", ".venv", "node_modules", "dist", "build"}
-_STATE_FILE = os.path.expanduser("~/.synth-ai/demo.json")
-
-
-@dataclass(slots=True)
-class ConfigCandidate:
-    path: Path
-    train_type: str  # "rl", "sft", or "unknown"
-
-
-def _load_last_config() -> Path | None:
-    """Load the last used training config path from state file."""
-    try:
-        if os.path.isfile(_STATE_FILE):
-            with open(_STATE_FILE) as fh:
-                data = json.load(fh)
-                if isinstance(data, dict):
-                    last_config = data.get("LAST_CONFIG")
-                    if last_config:
-                        path = Path(last_config).resolve()
-                        if path.exists():
-                            return path
-    except Exception:
-        pass
-    return None
-
-
-def _save_last_config(config_path: Path) -> None:
-    """Save the last used training config path to state file."""
-    try:
-        data = {}
-        if os.path.isfile(_STATE_FILE):
-            with open(_STATE_FILE) as fh:
-                data = json.load(fh) or {}
-        if not isinstance(data, dict):
-            data = {}
-        data["LAST_CONFIG"] = str(config_path.resolve())
-        os.makedirs(os.path.dirname(_STATE_FILE), exist_ok=True)
-        with open(_STATE_FILE, "w") as fh:
-            json.dump(data, fh)
-    except Exception:
-        pass
-
-
-def _iter_candidate_paths() -> Iterable[Path]:
-    seen: set[Path] = set()
-
-    # Prioritize current working directory first
-    try:
-        cwd = Path.cwd().resolve()
-    except Exception:
-        cwd = None
-    if cwd and cwd.exists():
-        for path in cwd.rglob("*.toml"):
-            if any(part in _SKIP_DIRS for part in path.parts):
-                continue
-            resolved = path.resolve()
-            if resolved in seen:
-                continue
-            seen.add(resolved)
-            yield resolved
-
-    # Then look in explicit config directories
-    preferred = [
-        REPO_ROOT / "configs",
-        REPO_ROOT / "examples",
-        REPO_ROOT / "training",
-    ]
-    for base in preferred:
-        if not base.exists():
-            continue
-        for path in base.rglob("*.toml"):
-            if any(part in _SKIP_DIRS for part in path.parts):
-                continue
-            resolved = path.resolve()
-            if resolved in seen:
-                continue
-            seen.add(resolved)
-            yield resolved
-
-
-def _infer_config_type(data: dict) -> str:
-    # 1) Strong signals from [algorithm]
-    algo = data.get("algorithm")
-    if isinstance(algo, dict):
-        method = str(algo.get("method") or "").lower()
-        algo_type = str(algo.get("type") or "").lower()
-        variety = str(algo.get("variety") or "").lower()
-
-        # RL indicators
-        if method in {"policy_gradient", "ppo", "reinforce"}:
-            return "rl"
-        if algo_type == "online":
-            return "rl"
-        if variety in {"gspo", "grpo", "ppo"}:
-            return "rl"
-
-        # SFT indicators
-        if method in {"supervised_finetune", "sft"}:
-            return "sft"
-        if algo_type == "offline":
-            return "sft"
-        if variety in {"fft"}:
-            return "sft"
-
-    # 2) Other RL signals
-    if data.get("job_type") == "rl":
-        return "rl"
-    services = data.get("services")
-    if isinstance(services, dict) and ("task_url" in services or "environment" in services):
-        return "rl"
-
-    # 3) Other SFT signals
-    training = data.get("training")
-    if isinstance(training, dict):
-        mode = str(training.get("mode") or "").lower()
-        if mode.startswith("sft") or mode == "sft_offline":
-            return "sft"
-    hyper = data.get("hyperparameters")
-    if isinstance(hyper, dict):
-        kind = str(hyper.get("train_kind") or "").lower()
-        if kind in {"sft", "fft"}:
-            return "sft"
-
-    # 4) Fallback
-    return "unknown"
-
-
-def discover_configs(explicit: list[str], *, requested_type: str | None) -> list[ConfigCandidate]:
-    candidates: list[ConfigCandidate] = []
-    seen: set[Path] = set()
-
-    for raw in explicit:
-        path = Path(raw).expanduser().resolve()
-        if not path.exists():
-            raise click.ClickException(f"Config not found: {path}")
-        data = load_toml(path)
-        cfg_type = _infer_config_type(data)
-        candidates.append(ConfigCandidate(path=path, train_type=cfg_type))
-        seen.add(path)
-
-    if explicit:
-        return candidates
-
-    for path in _iter_candidate_paths():
-        if path in seen:
-            continue
-        try:
-            data = load_toml(path)
-        except Exception:
-            continue
-        cfg_type = _infer_config_type(data)
-        candidates.append(ConfigCandidate(path=path, train_type=cfg_type))
-
-    if requested_type and requested_type != "auto":
-        candidates = [c for c in candidates if c.train_type in {requested_type, "unknown"}]
-
-    # De-dupe by path and keep deterministic ordering by directory depth then name
-    candidates.sort(key=lambda c: (len(c.path.parts), str(c.path)))
-    return candidates
-
-
-def prompt_for_config(
-    candidates: list[ConfigCandidate], *, requested_type: str | None, allow_autoselect: bool = False
-) -> ConfigCandidate:
-    if not candidates:
-        raise click.ClickException("No training configs found. Pass --config explicitly.")
-
-    # Check for last used config and move it to the top if found
-    last_config = _load_last_config()
-    default_idx = 1
-
-    if allow_autoselect and len(candidates) == 1:
-        chosen = candidates[0]
-        _save_last_config(chosen.path)
-        return chosen
-
-    if last_config:
-        for idx, cand in enumerate(candidates):
-            if cand.path.resolve() == last_config:
-                # Move last used config to the front
-                candidates.insert(0, candidates.pop(idx))
-                break
-
-    click.echo("Select a training config:")
-    for idx, cand in enumerate(candidates, start=1):
-        label = cand.train_type if cand.train_type != "unknown" else "?"
-        last_marker = " (last used)" if last_config and cand.path.resolve() == last_config else ""
-        click.echo(f"  {idx}) [{label}] {cand.path}{last_marker}")
-    click.echo("  0) Abort")
-
-    choice = click.prompt("Enter choice", type=int, default=default_idx)
-    if choice == 0:
-        raise click.ClickException("Aborted by user")
-    if choice < 0 or choice > len(candidates):
-        raise click.ClickException("Invalid selection")
-
-    selection = candidates[choice - 1]
-
-    # Save this config as the last used
-    _save_last_config(selection.path)
-
-    try:
-        data = load_toml(selection.path)
-        preview = preview_json({k: data.get(k) for k in list(data.keys())[:4]}, limit=320)
-        click.echo(f"Loaded {selection.path}: {preview}")
-    except Exception:
-        pass
-    return selection
-
-
-__all__ = [
-    "ConfigCandidate",
-    "discover_configs",
-    "prompt_for_config",
-]

synth_ai/api/train/configs/__init__.py

@@ -1,44 +0,0 @@
-"""Typed training config loaders for RL and SFT jobs."""
-
-from .rl import (
-    EvaluationConfig,
-    JudgeConfig,
-    JudgeOptionsConfig,
-    ModelConfig,
-    RLConfig,
-    RLServicesConfig,
-    RLTrainingConfig,
-    RolloutConfig,
-    WeightSyncConfig,
-)
-from .sft import (
-    HyperparametersConfig,
-    HyperparametersParallelism,
-    JobConfig,
-    SFTConfig,
-    SFTDataConfig,
-    TrainingConfig,
-    TrainingValidationConfig,
-)
-from .shared import AlgorithmConfig, ComputeConfig
-
-__all__ = [
-    "AlgorithmConfig",
-    "ComputeConfig",
-    "EvaluationConfig",
-    "HyperparametersConfig",
-    "HyperparametersParallelism",
-    "JobConfig",
-    "JudgeConfig",
-    "JudgeOptionsConfig",
-    "ModelConfig",
-    "RLConfig",
-    "RLServicesConfig",
-    "RLTrainingConfig",
-    "RolloutConfig",
-    "SFTConfig",
-    "SFTDataConfig",
-    "TrainingConfig",
-    "TrainingValidationConfig",
-    "WeightSyncConfig",
-]

synth_ai/api/train/configs/rl.py

@@ -1,134 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Mapping
-from pathlib import Path
-from typing import Any
-
-from pydantic import model_validator
-
-from ..utils import load_toml
-from .shared import AlgorithmConfig, ComputeConfig, ExtraModel
-
-
-class RLServicesConfig(ExtraModel):
-    task_url: str
-    judge_url: str | None = None
-
-
-class ModelConfig(ExtraModel):
-    source: str | None = None
-    base: str | None = None
-    trainer_mode: str
-    label: str
-
-    @model_validator(mode="after")
-    def _ensure_exactly_one_source_or_base(self) -> ModelConfig:
-        if bool(self.source) == bool(self.base):
-            raise ValueError("Config must set exactly one of [model].source or [model].base")
-        return self
-
-
-class RolloutConfig(ExtraModel):
-    env_name: str
-    policy_name: str
-    env_config: dict[str, Any] | None = None
-    policy_config: dict[str, Any] | None = None
-    max_turns: int
-    episodes_per_batch: int
-    max_concurrent_rollouts: int
-    batches_per_step: int | None = None
-    ops: list[str] | None = None
-
-
-class WeightSyncConfig(ExtraModel):
-    enable: bool | None = None
-    targets: list[str] | None = None
-    mode: str | None = None
-    direct: bool | None = None
-    verify_every_k: int | None = None
-
-
-class RLTrainingConfig(ExtraModel):
-    num_epochs: int
-    iterations_per_epoch: int
-    gradient_accumulation_steps: int | None = None
-    max_accumulated_minibatch: int | None = None
-    max_turns: int
-    batch_size: int
-    group_size: int
-    learning_rate: float
-    log_interval: int | None = None
-    weight_sync_interval: int | None = None
-    step_rewards_enabled: bool | None = None
-    step_rewards_mode: str | None = None
-    step_rewards_indicator_lambda: float | None = None
-    step_rewards_beta: float | None = None
-    step_rewards_strategy: str | None = None
-    event_rewards_kind: str | None = None
-    weight_sync: WeightSyncConfig | None = None
-
-
-class EvaluationConfig(ExtraModel):
-    instances: int
-    every_n_iters: int
-    seeds: list[int]
-
-
-class JudgeOptionsConfig(ExtraModel):
-    event: bool | None = None
-    outcome: bool | None = None
-    provider: str | None = None
-    model: str | None = None
-    rubric_id: str | None = None
-    rubric_overrides: dict[str, Any] | None = None
-    tracks: list[str] | None = None
-    weights: dict[str, float] | None = None
-    max_concurrency: int | None = None
-
-
-class JudgeConfig(ExtraModel):
-    type: str | None = None
-    timeout_s: int | None = None
-    options: JudgeOptionsConfig | None = None
-
-
-class RLConfig(ExtraModel):
-    algorithm: AlgorithmConfig
-    services: RLServicesConfig
-    compute: ComputeConfig | None = None
-    topology: dict[str, Any] | None = None
-    vllm: dict[str, Any] | None = None
-    reference: dict[str, Any] | None = None
-    model: ModelConfig
-    lora: dict[str, Any] | None = None
-    rollout: RolloutConfig | None = None
-    evaluation: EvaluationConfig | None = None
-    training: RLTrainingConfig | None = None
-    rubric: dict[str, Any] | None = None
-    judge: JudgeConfig | None = None
-    tags: dict[str, Any] | None = None
-
-    def to_dict(self) -> dict[str, Any]:
-        return self.model_dump(mode="python", exclude_none=True)
-
-    @classmethod
-    def from_mapping(cls, data: Mapping[str, Any]) -> RLConfig:
-        return cls.model_validate(dict(data))
-
-    @classmethod
-    def from_path(cls, path: Path) -> RLConfig:
-        content = load_toml(path)
-        return cls.from_mapping(content)
-
-
-__all__ = [
-    "EvaluationConfig",
-    "JudgeConfig",
-    "JudgeOptionsConfig",
-    "ModelConfig",
-    "RLConfig",
-    "RLServicesConfig",
-    "RLTrainingConfig",
-    "RolloutConfig",
-    "WeightSyncConfig",
-]

synth_ai/api/train/configs/sft.py

@@ -1,95 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import Mapping
-from pathlib import Path
-from typing import Any
-
-from pydantic import Field
-
-from ..utils import load_toml
-from .shared import AlgorithmConfig, ComputeConfig, ExtraModel
-
-
-class JobConfig(ExtraModel):
-    model: str
-    data: str | None = None
-    data_path: str | None = None
-    poll_seconds: int | None = None
-
-
-class SFTDataConfig(ExtraModel):
-    topology: dict[str, Any] | None = None
-    validation_path: str | None = None
-
-
-class TrainingValidationConfig(ExtraModel):
-    enabled: bool | None = None
-    evaluation_strategy: str | None = None
-    eval_steps: int | None = None
-    save_best_model_at_end: bool | None = None
-    metric_for_best_model: str | None = None
-    greater_is_better: bool | None = None
-
-
-class TrainingConfig(ExtraModel):
-    mode: str | None = None
-    use_qlora: bool | None = None
-    validation: TrainingValidationConfig | None = None
-
-
-class HyperparametersParallelism(ExtraModel):
-    use_deepspeed: bool | None = None
-    deepspeed_stage: int | None = None
-    fsdp: bool | None = None
-    bf16: bool | None = None
-    fp16: bool | None = None
-    activation_checkpointing: bool | None = None
-    tensor_parallel_size: int | None = None
-    pipeline_parallel_size: int | None = None
-
-
-class HyperparametersConfig(ExtraModel):
-    n_epochs: int = 1
-    batch_size: int | None = None
-    global_batch: int | None = None
-    per_device_batch: int | None = None
-    gradient_accumulation_steps: int | None = None
-    sequence_length: int | None = None
-    learning_rate: float | None = None
-    warmup_ratio: float | None = None
-    train_kind: str | None = None
-    weight_decay: float | None = None
-    parallelism: HyperparametersParallelism | None = None
-
-
-class SFTConfig(ExtraModel):
-    algorithm: AlgorithmConfig | None = None
-    job: JobConfig
-    compute: ComputeConfig | None = None
-    data: SFTDataConfig | None = None
-    training: TrainingConfig | None = None
-    hyperparameters: HyperparametersConfig = Field(default_factory=HyperparametersConfig)
-    tags: dict[str, Any] | None = None
-
-    def to_dict(self) -> dict[str, Any]:
-        return self.model_dump(mode="python", exclude_none=True)
-
-    @classmethod
-    def from_mapping(cls, data: Mapping[str, Any]) -> SFTConfig:
-        return cls.model_validate(dict(data))
-
-    @classmethod
-    def from_path(cls, path: Path) -> SFTConfig:
-        content = load_toml(path)
-        return cls.from_mapping(content)
-
-
-__all__ = [
-    "HyperparametersConfig",
-    "HyperparametersParallelism",
-    "JobConfig",
-    "SFTConfig",
-    "SFTDataConfig",
-    "TrainingConfig",
-    "TrainingValidationConfig",
-]

synth_ai/api/train/configs/shared.py

@@ -1,24 +0,0 @@
-from __future__ import annotations
-
-from pydantic import BaseModel, ConfigDict
-
-
-class ExtraModel(BaseModel):
-    """Base model that tolerates unknown keys so configs keep forward compatibility."""
-
-    model_config = ConfigDict(extra="allow")
-
-
-class AlgorithmConfig(ExtraModel):
-    type: str
-    method: str
-    variety: str
-
-
-class ComputeConfig(ExtraModel):
-    gpu_type: str
-    gpu_count: int
-    nodes: int | None = None
-
-
-__all__ = ["ExtraModel", "AlgorithmConfig", "ComputeConfig"]