synth-ai 0.2.9.dev4__py3-none-any.whl → 0.2.9.dev6__py3-none-any.whl

examples/qwen_coder/infer_prod_proxy.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""Smoke test: Qwen3 Coder inference via the Synth prod proxy endpoint.
+
+No CLI args. Reads SYNTH_API_KEY from env. Optional overrides via env:
+  - BACKEND_BASE_URL (defaults to https://agent-learning.onrender.com/api)
+  - MODEL (defaults to Qwen/Qwen3-Coder-30B-A3B-Instruct)
+  - PROMPT (defaults to a simple coding prompt)
+
+Run:
+  SYNTH_API_KEY=sk_... uv run python examples/qwen_coder/infer_prod_proxy.py
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from typing import Any
+
+import httpx
+
+
+def _backend_root() -> str:
+    raw = os.getenv("BACKEND_BASE_URL", "https://agent-learning.onrender.com/api").strip()
+    if raw.endswith("/api"):
+        raw = raw[:-4]
+    return raw.rstrip("/")
+
+
+async def main() -> None:
+    api_key = os.getenv("SYNTH_API_KEY", "").strip()
+    if not api_key:
+        raise SystemExit("SYNTH_API_KEY required in environment")
+
+    model = os.getenv("MODEL", "Qwen/Qwen3-Coder-30B-A3B-Instruct")
+    prompt = os.getenv(
+        "PROMPT",
+        "Write a Python function to reverse a string, then show an example call.",
+    )
+
+    # Prod proxy endpoint
+    url = f"{_backend_root()}/api/inference/v1/chat/completions"
+
+    payload: dict[str, Any] = {
+        "model": model,
+        "messages": [{"role": "user", "content": prompt}],
+        "temperature": 0.2,
+        "max_tokens": 256,
+        "thinking_budget": 256,
+    }
+
+    async with httpx.AsyncClient(timeout=60.0) as http:
+        resp = await http.post(
+            url,
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            },
+            json=payload,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        # Print assistant content (compact)
+        try:
+            msg = data.get("choices", [{}])[0].get("message", {})
+            print(msg.get("content") or data)
+        except Exception:
+            print(data)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+
+

examples/qwen_coder/infer_via_synth.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""One-shot inference for Qwen3 (and Coder) models via the Synth backend proxy.
+
+Usage examples:
+
+  SYNTH_API_KEY=sk_... BACKEND_BASE_URL=https://agent-learning.onrender.com/api \
+  uv run python examples/qwen_coder/infer_via_synth.py \
+    --model Qwen/Qwen3-Coder-30B-A3B-Instruct \
+    --prompt "Write a Python function to reverse a string." \
+    --max-tokens 128 --temperature 0.2
+
+Optionally you can point to a specific inference host (e.g., your vLLM or task-app proxy):
+
+  ... infer_via_synth.py --inference-url https://your-host/api/inference
+
+The script defaults the backend base URL to the hosted service if BACKEND_BASE_URL is not set.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import os
+from typing import Any
+
+from synth_ai.inference.client import InferenceClient
+
+
+def _default_backend() -> str:
+    raw = os.getenv("BACKEND_BASE_URL", "https://agent-learning.onrender.com/api").strip()
+    return raw if raw.endswith("/api") else (raw + "/api")
+
+
+async def main() -> None:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument(
+        "--model",
+        default=os.getenv("MODEL", "Qwen/Qwen3-Coder-30B-A3B-Instruct"),
+        help="Base or ft:<id> model identifier",
+    )
+    p.add_argument(
+        "--prompt",
+        default="Write a Python function to reverse a string.",
+        help="User prompt text",
+    )
+    p.add_argument("--max-tokens", type=int, default=256)
+    p.add_argument("--temperature", type=float, default=0.2)
+    p.add_argument(
+        "--inference-url",
+        default=os.getenv("INFERENCE_URL"),
+        help="Optional backend inference base (e.g., https://host/api/inference)",
+    )
+    p.add_argument(
+        "--timeout", type=float, default=60.0, help="HTTP timeout seconds for backend calls"
+    )
+    args = p.parse_args()
+
+    backend = _default_backend()
+    api_key = os.getenv("SYNTH_API_KEY", "").strip()
+    if not api_key:
+        raise SystemExit("SYNTH_API_KEY required (export it or pass via env-file to uvx)")
+
+    client = InferenceClient(base_url=backend, api_key=api_key, timeout=args.timeout)
+
+    body: dict[str, Any] = {
+        "model": args.model,
+        "messages": [{"role": "user", "content": args.prompt}],
+        "max_tokens": int(args.max_tokens),
+        "temperature": float(args.temperature),
+    }
+    if args.inference_url:
+        # Backend supports forwarding to a specific host when provided
+        body["inference_url"] = str(args.inference_url)
+
+    resp = await client.create_chat_completion(**body)
+    try:
+        msg = resp.get("choices", [{}])[0].get("message", {})
+        content = msg.get("content")
+        print(content or resp)
+    except Exception:
+        print(resp)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+
+

examples/qwen_coder/scripts/infer_coder.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Optional: pass a .env path as first arg; otherwise relies on current env
+ENV_FILE=${1:-}
+
+if [[ -n "${ENV_FILE}" ]]; then
+  if [[ ! -f "${ENV_FILE}" ]]; then
+    echo "Env file not found: ${ENV_FILE}" >&2
+    exit 1
+  fi
+  set -a; source "${ENV_FILE}"; set +a
+fi
+
+# Use prod proxy smoke (base or ft:... via MODEL env)
+uv run python examples/qwen_coder/infer_prod_proxy.py
+
+

examples/qwen_coder/scripts/train_coder_30b.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Optional: pass a .env path as first arg; otherwise relies on current env
+ENV_FILE=${1:-}
+
+if [[ -n "${ENV_FILE}" ]]; then
+  if [[ ! -f "${ENV_FILE}" ]]; then
+    echo "Env file not found: ${ENV_FILE}" >&2
+    exit 1
+  fi
+  set -a; source "${ENV_FILE}"; set +a
+fi
+
+uvx synth-ai train \
+  --type sft \
+  --config examples/qwen_coder/configs/coder_lora_30b.toml \
+  --dataset examples/qwen_coder/ft_data/coder_sft.small.jsonl \
+  --env-file "${ENV_FILE:-}"
+
+

examples/qwen_coder/sft_full_17b.py

@@ -0,0 +1,103 @@
+#!/usr/bin/env python3
+"""Submit a full-parameter SFT job for Qwen/Qwen3-1.7B via Synth API."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from typing import Any
+
+from examples.qwen_coder._shared import (
+    ensure_tiny_dataset,
+    optional_validation_dataset,
+    resolve_output_path,
+)
+from synth_ai.learning.client import LearningClient
+
+
+def _backend() -> str:
+    raw = os.getenv("BACKEND_BASE_URL", "https://agent-learning.onrender.com/api").strip()
+    return raw if raw.endswith("/api") else (raw + "/api")
+
+
+async def main() -> None:
+    api_key = os.getenv("SYNTH_API_KEY", "").strip()
+    if not api_key:
+        raise SystemExit("SYNTH_API_KEY required in env")
+
+    backend = _backend()
+    client = LearningClient(base_url=backend, api_key=api_key, timeout=60.0)
+
+    data_path = ensure_tiny_dataset()
+    file_id = await client.upload_training_file(str(data_path))
+
+    validation_file_id: str | None = None
+    val_path = optional_validation_dataset()
+    if val_path and val_path.exists():
+        validation_file_id = await client.upload_training_file(str(val_path))
+
+    hyper: dict[str, Any] = {
+        "n_epochs": int(os.getenv("QWEN_CODER_FULL_EPOCHS", "1")),
+        "per_device_batch": int(os.getenv("QWEN_CODER_FULL_PER_DEVICE", "1")),
+        "gradient_accumulation_steps": int(os.getenv("QWEN_CODER_FULL_ACCUM", "8")),
+        "sequence_length": int(os.getenv("QWEN_CODER_FULL_SEQ_LEN", "4096")),
+        "learning_rate": float(os.getenv("QWEN_CODER_FULL_LR", "2e-5")),
+        "warmup_ratio": float(os.getenv("QWEN_CODER_FULL_WARMUP", "0.05")),
+        "train_kind": os.getenv("QWEN_CODER_FULL_TRAIN_KIND", "full"),
+    }
+
+    metadata = {
+        "example": "qwen_coder_full_17b",
+        "effective_config": {
+            "compute": {
+                "gpu_type": os.getenv("SYNTH_GPU_TYPE", "H100"),
+                "gpu_count": int(os.getenv("SYNTH_GPU_COUNT", "4")),
+                "nodes": int(os.getenv("SYNTH_GPU_NODES", "1")),
+            }
+        },
+    }
+
+    job = await client.create_job(
+        training_type="sft_offline",
+        model=os.getenv("QWEN_CODER_FULL_MODEL", "Qwen/Qwen3-1.7B"),
+        training_file_id=file_id,
+        hyperparameters=hyper,
+        metadata=metadata,
+        validation_file=validation_file_id,
+    )
+    job_id = str(job.get("id") or job.get("job_id") or "").strip()
+    if not job_id:
+        raise SystemExit(f"Invalid create_job response: {job}")
+
+    await client.start_job(job_id)
+
+    timeout_seconds = float(os.getenv("SYNTH_TIMEOUT", "7200"))
+    poll_interval = float(os.getenv("QWEN_CODER_FULL_POLL_INTERVAL", "10"))
+
+    job_final = await client.poll_until_terminal(
+        job_id,
+        interval_seconds=poll_interval,
+        max_seconds=timeout_seconds,
+    )
+
+    status = str(job_final.get("status"))
+    print(f"Job status: {status}")
+    result_model = (
+        job_final.get("result", {}).get("model_id")
+        if isinstance(job_final.get("result"), dict)
+        else None
+    )
+    print(f"Model ID: {result_model}")
+    try:
+        out_file = resolve_output_path("ft_model_id_full.txt")
+        text = (result_model or "").strip()
+        if text:
+            out_file.write_text(text + "\n", encoding="utf-8")
+            print(f"Wrote {out_file} with ft model id")
+    except Exception as exc:
+        print(f"Warning: failed to write ft_model_id_full.txt: {exc}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
+

examples/qwen_coder/sft_lora_30b.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""Submit a LoRA SFT job for Qwen/Qwen3-Coder-30B-A3B-Instruct via Synth API.
+
+Steps:
+  - Generate a tiny coder dataset if missing
+  - Upload the JSONL
+  - Create the job with coder LoRA hyperparameters
+  - Start and poll until terminal, then print the resulting model id
+
+Env:
+  SYNTH_API_KEY (required)
+  BACKEND_BASE_URL (defaults to https://agent-learning.onrender.com/api)
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from typing import Any
+
+from examples.qwen_coder._shared import (
+    ensure_tiny_dataset,
+    optional_validation_dataset,
+    resolve_output_path,
+)
+from synth_ai.learning.client import LearningClient
+
+
+def _backend() -> str:
+    raw = os.getenv("BACKEND_BASE_URL", "https://agent-learning.onrender.com/api").strip()
+    return raw if raw.endswith("/api") else (raw + "/api")
+
+
+async def main() -> None:
+    api_key = os.getenv("SYNTH_API_KEY", "").strip()
+    if not api_key:
+        raise SystemExit("SYNTH_API_KEY required in env")
+
+    backend = _backend()
+    client = LearningClient(base_url=backend, api_key=api_key, timeout=60.0)
+
+    # Ensure dataset exists
+    data_path = ensure_tiny_dataset()
+
+    # Upload training file
+    file_id = await client.upload_training_file(str(data_path))
+
+    # Optional validation file if present alongside training set
+    val_path = optional_validation_dataset()
+    validation_file_id: str | None = None
+    if val_path and val_path.exists():
+        validation_file_id = await client.upload_training_file(str(val_path))
+
+    # Minimal hyperparameters for LoRA SFT (aligned with coder_lora_30b.toml)
+    hyper: dict[str, Any] = {
+        "n_epochs": 1,
+        "per_device_batch": 1,
+        "gradient_accumulation_steps": 64,
+        "sequence_length": 4096,
+        "learning_rate": 5e-6,
+        "warmup_ratio": 0.03,
+        "train_kind": "peft",
+    }
+
+    # Create job
+    job = await client.create_job(
+        training_type="sft_offline",
+        model="Qwen/Qwen3-Coder-30B-A3B-Instruct",
+        training_file_id=file_id,
+        hyperparameters=hyper,
+        metadata={
+            "example": "qwen_coder_lora_30b",
+            # Include effective compute hints for backend routing/validation
+            "effective_config": {
+                "compute": {"gpu_type": "H100", "gpu_count": 4, "nodes": 1}
+            },
+        },
+        validation_file=validation_file_id,
+    )
+    job_id = str(job.get("id"))
+    if not job_id:
+        raise SystemExit(f"Invalid create_job response: {job}")
+
+    # Start
+    await client.start_job(job_id)
+
+    # Poll until terminal
+    job_final = await client.poll_until_terminal(job_id, interval_seconds=5.0, max_seconds=7200)
+    status = str(job_final.get("status"))
+    print(f"Job status: {status}")
+    # Print resulting model id if available and write to ft_data/ft_model_id.txt
+    result_model = (
+        job_final.get("result", {}).get("model_id")
+        if isinstance(job_final.get("result"), dict)
+        else None
+    )
+    print(f"Model ID: {result_model}")
+    try:
+        out_file = resolve_output_path("ft_model_id.txt")
+        text = (result_model or "").strip()
+        if text:
+            out_file.write_text(text + "\n", encoding="utf-8")
+            print(f"Wrote {out_file} with ft model id")
+    except Exception as exc:
+        # Best-effort write; don't crash if filesystem issues
+        print(f"Warning: failed to write ft_model_id.txt: {exc}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

examples/qwen_coder/subset_jsonl.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+"""Create a capped subset of a JSONL dataset for quick runs."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("src", help="Source JSONL path")
+    p.add_argument("dst", help="Destination JSONL path")
+    p.add_argument("--n", type=int, default=200, help="Max examples to keep")
+    args = p.parse_args()
+
+    src = Path(args.src)
+    if not src.exists():
+        raise SystemExit(f"No such file: {src}")
+    dst = Path(args.dst)
+    dst.parent.mkdir(parents=True, exist_ok=True)
+
+    kept = 0
+    with src.open("r", encoding="utf-8") as fin, dst.open("w", encoding="utf-8") as fout:
+        for line in fin:
+            if kept >= args.n:
+                break
+            if not line.strip():
+                continue
+            fout.write(line)
+            kept += 1
+    print(f"Wrote {dst} with {kept} lines")
+
+
+if __name__ == "__main__":
+    main()
+
+

examples/qwen_coder/validate_jsonl.py

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+"""Validate that a JSONL file parses and contains chat-like records.
+
+Checks first N lines (default 50) for objects with `messages` including an
+assistant response (role == "assistant").
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+
+def main() -> None:
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument("path", help="Path to JSONL file")
+    p.add_argument("--n", type=int, default=50, help="Number of lines to sample")
+    args = p.parse_args()
+
+    src = Path(args.path)
+    if not src.exists():
+        raise SystemExit(f"No such file: {src}")
+
+    checked = 0
+    ok = 0
+    with src.open("r", encoding="utf-8") as f:
+        for i, line in enumerate(f, start=1):
+            if i > args.n:
+                break
+            line = line.strip()
+            if not line:
+                continue
+            checked += 1
+            try:
+                obj = json.loads(line)
+            except Exception as exc:
+                raise SystemExit(f"Line {i} is not valid JSON: {exc}")
+            msgs = obj.get("messages") if isinstance(obj, dict) else None
+            if not isinstance(msgs, list):
+                raise SystemExit(f"Line {i} missing 'messages' list")
+            has_assistant = any(
+                isinstance(m, dict) and m.get("role") == "assistant" and m.get("content")
+                for m in msgs
+            )
+            if has_assistant:
+                ok += 1
+
+    if checked == 0:
+        raise SystemExit("No lines checked; file empty?")
+    if ok == 0:
+        raise SystemExit("No assistant messages found in sampled lines")
+    print(f"Validated: {ok}/{checked} sampled lines contain assistant messages")
+
+
+if __name__ == "__main__":
+    main()
+
+

examples/rl/configs/eval_base_qwen.toml

@@ -6,7 +6,7 @@ num_episodes = 50
 seed_start = 0
 
 [policy]
-inference_url = "http://localhost:8000/api/inference"
+inference_url = "https://agent-learning.onrender.com/api/inference"
 max_tokens = 128
 temperature = 0.0
 

examples/rl/configs/rl_from_base_qwen17.toml

@@ -11,7 +11,7 @@ base = "Qwen/Qwen3-1.7B"
 
 [policy]
 model = "Qwen/Qwen3-1.7B"
-inference_url = "http://localhost:8000/api/inference"
+inference_url = "https://agent-learning.onrender.com/api/inference"
 max_tokens = 1028
 temperature = 0.2
 

examples/rl/download_dataset.py

@@ -20,10 +20,12 @@ def extract_examples(dataset: Any, *, limit: int | None) -> list[dict[str, str]]
         solution = item.get("solution") or ""
         if isinstance(solution, list):
             solution = "\n".join(str(part) for part in solution)
-        examples.append({
-            "problem": problem,
-            "solution": solution,
-        })
+        examples.append(
+            {
+                "problem": problem,
+                "solution": solution,
+            }
+        )
     return examples
 
 
@@ -35,12 +37,26 @@ def write_jsonl(path: Path, rows: list[dict[str, str]]) -> None:
 
 
 def main() -> None:
-    parser = argparse.ArgumentParser(description="Download MATH dataset splits to JSONL for offline use")
-    parser.add_argument("--output-dir", default="examples/rl/data", help="Directory to write <split>.jsonl files")
-    parser.add_argument("--dataset", default="nlile/hendrycks-MATH-benchmark", help="Hugging Face dataset identifier")
-    parser.add_argument("--config", default="algebra", help="Hugging Face dataset config (if required)")
-    parser.add_argument("--splits", nargs="*", default=["train", "validation", "test"], help="Splits to download")
-    parser.add_argument("--limit", type=int, default=None, help="Optional cap on examples per split")
+    parser = argparse.ArgumentParser(
+        description="Download MATH dataset splits to JSONL for offline use"
+    )
+    parser.add_argument(
+        "--output-dir", default="examples/rl/data", help="Directory to write <split>.jsonl files"
+    )
+    parser.add_argument(
+        "--dataset",
+        default="nlile/hendrycks-MATH-benchmark",
+        help="Hugging Face dataset identifier",
+    )
+    parser.add_argument(
+        "--config", default="algebra", help="Hugging Face dataset config (if required)"
+    )
+    parser.add_argument(
+        "--splits", nargs="*", default=["train", "validation", "test"], help="Splits to download"
+    )
+    parser.add_argument(
+        "--limit", type=int, default=None, help="Optional cap on examples per split"
+    )
     args = parser.parse_args()
 
     output_dir = Path(args.output_dir).expanduser()