synth-ai 0.2.6.dev1__py3-none-any.whl → 0.4.3__py3-none-any.whl

synth_ai/environments/examples/crafter_classic/agent_demos/old/kick_off_ft_gemini.py

@@ -1,150 +0,0 @@
-```python
-#!/usr/bin/env python3
-"""
-Vertex AI Fine‑Tuning Script (Gemini Flash)
-==========================================
-Uploads a JSONL file to GCS, starts a Gemini‑Flash tuning job, and polls until completion.
-"""
-
-import os
-import sys
-import time
-import argparse
-import json
-import random
-from pathlib import Path
-from typing import Optional
-
-# --- Lazy‑install required packages -----------------------------------------
-def _lazy_import(pkg: str, pip_name: Optional[str] = None):
-    try:
-        return __import__(pkg)
-    except ImportError:                               # pragma: no cover
-        print(f"📦 Installing {pkg}…")
-        os.system(f"pip install {pip_name or pkg}")
-        return __import__(pkg)
-
-storage   = _lazy_import("google.cloud.storage")
-aiplatform = _lazy_import("google.cloud.aiplatform")
-vertexai   = _lazy_import("vertexai")
-generative_models = _lazy_import("vertexai.preview.generative_models")
-
-tiktoken  = _lazy_import("tiktoken")
-
-# --- Helpers ----------------------------------------------------------------
-def encoding_for(model: str = "cl100k_base"):
-    try:
-        return tiktoken.encoding_for_model(model)
-    except KeyError:
-        return tiktoken.get_encoding("cl100k_base")
-
-def analyze_jsonl_tokens(file_path: Path, model: str) -> tuple[int, int, float]:
-    enc = encoding_for(model)
-    inp_tok = out_tok = lines = 0
-    with open(file_path, "r") as fh:
-        for ln, raw in enumerate(fh, 1):
-            try:
-                data = json.loads(raw)
-            except json.JSONDecodeError:
-                continue
-            msgs = data.get("messages", [])
-            input_text = " ".join(m["content"] for m in msgs[:-1] if m.get("content"))
-            output_text = msgs[-1]["content"] if msgs else ""
-            inp_tok += len(enc.encode(input_text))
-            out_tok += len(enc.encode(output_text))
-            lines += 1
-    avg = (inp_tok + out_tok) / lines if lines else 0
-    print(f"🔍 {lines:,} lines ‑ {inp_tok+out_tok:,} tokens (avg ≈ {avg:.1f}/line)")
-    return lines, inp_tok + out_tok, avg
-
-def create_subset_file(src: Path, n: int) -> Path:
-    dst = src.with_name(f"{src.stem}_subset_{n}.jsonl")
-    lines = [l.strip() for l in src.open() if l.strip()]
-    if n < len(lines):
-        lines = random.sample(lines, n)
-    with dst.open("w") as fh:
-        fh.write("\n".join(lines) + "\n")
-    return dst
-
-def upload_to_gcs(bucket: str, file_path: Path) -> str:
-    client = storage.Client()
-    bkt = client.bucket(bucket)
-    blob = bkt.blob(file_path.name)
-    blob.upload_from_filename(file_path)
-    uri = f"gs://{bucket}/{file_path.name}"
-    print(f"📤 Uploaded to {uri}")
-    return uri
-
-def start_tuning_job(project: str, region: str, gcs_uri: str,
-                     base_model: str, display_name: str,
-                     epochs: int, lr_mult: float):
-    vertexai.init(project=project, location=region)
-    model = generative_models.GenerativeModel(base_model)
-    job = model.tune_model(
-        training_data=generative_models.FileData(
-            path=gcs_uri, mime_type="jsonl"),
-        tuned_model_display_name=display_name,
-        hyperparameters={
-            "epochs": epochs,
-            "learning_rate_multiplier": lr_mult,
-        },
-    )
-    return job
-
-def wait(job, poll: int):
-    print("⏳ Waiting for tuning to finish…")
-    while True:
-        job.refresh()
-        state = job.state
-        print(f"   Status: {state}")
-        if state in ("SUCCEEDED", "FAILED", "CANCELLED"):
-            break
-        time.sleep(poll)
-    return state
-
-# --- Main -------------------------------------------------------------------
-def main():
-    ap = argparse.ArgumentParser(description="Vertex AI Gemini‑Flash Fine‑Tuning")
-    ap.add_argument("jsonl_file", type=Path, help="Training data (JSONL)")
-    ap.add_argument("--project", required=True)
-    ap.add_argument("--region", default="us‑central1")
-    ap.add_argument("--bucket", required=True, help="GCS bucket for upload")
-    ap.add_argument("--model", default="gemini‑1.0‑flash")
-    ap.add_argument("--display-name", default="gemini-flash-tuned")
-    ap.add_argument("--epochs", type=int, default=3)
-    ap.add_argument("--lr-mult", type=float, default=0.05)
-    ap.add_argument("--poll-interval", type=int, default=60)
-    args = ap.parse_args()
-
-    if not args.jsonl_file.exists():
-        sys.exit("❌ Training file not found.")
-
-    lines, total_tok, _ = analyze_jsonl_tokens(args.jsonl_file, args.model)
-
-    subset = input("Use subset? (y/N): ").strip().lower()
-    train_file = args.jsonl_file
-    if subset == "y":
-        n = int(input(f"Lines (1‑{lines}): "))
-        train_file = create_subset_file(args.jsonl_file, n)
-
-    gcs_uri = upload_to_gcs(args.bucket, train_file)
-    job = start_tuning_job(args.project, args.region, gcs_uri,
-                           args.model, args.display_name,
-                           args.epochs, args.lr_mult)
-    final_state = wait(job, args.poll_interval)
-
-    if final_state == "SUCCEEDED":
-        print(f"🎉 Tuned model: {job.resource_name}")
-        print("\n📝 Usage example:")
-        print(f"""
-from vertexai.preview import generative_models
-vertexai.init(project="{args.project}", location="{args.region}")
-model = generative_models.GenerativeModel("{job.resource_name}")
-resp = model.generate_content("Hello!")
-print(resp.text)
-""")
-    else:
-        sys.exit("❌ Tuning did not succeed.")
-
-if __name__ == "__main__":
-    main()

synth_ai/environments/examples/crafter_classic/agent_demos/old/kick_off_ft_modal.py

@@ -1,283 +0,0 @@
-#!/usr/bin/env python3
-"""
-Script to kick off fine-tuning jobs on Modal using generated Crafter rollout data
-"""
-
-import argparse
-import asyncio
-import json
-import os
-from datetime import datetime
-from pathlib import Path
-from typing import Optional
-
-import httpx
-
-# Modal API configuration
-MODAL_BASE_URL = "https://synth-laboratories--unified-ft-service-fastapi-app.modal.run"
-MODAL_API_KEY = os.environ.get("MODAL_API_KEY", "sk-test-11111111111111111111111111111111")
-
-# Default hyperparameters for Crafter fine-tuning
-DEFAULT_HYPERPARAMS = {
-    "n_epochs": 3,
-    "batch_size": 4,
-    "learning_rate_multiplier": 2.0,
-    "use_qlora": False,  # Can enable for larger models
-}
-
-# Supported base models for fine-tuning
-SUPPORTED_MODELS = [
-    "Qwen/Qwen2.5-0.5B-Instruct",
-    "Qwen/Qwen2.5-1.5B-Instruct",
-    "Qwen/Qwen2.5-3B-Instruct",
-    "Qwen/Qwen2.5-7B-Instruct",
-    "Qwen/Qwen2.5-14B-Instruct",
-    "Qwen/Qwen2.5-32B-Instruct",
-    "Qwen/Qwen2.5-72B-Instruct",
-]
-
-
-async def upload_training_file(file_path: Path, api_key: str) -> str:
-    """Upload a training file to Modal and return the file ID."""
-    async with httpx.AsyncClient(timeout=60.0) as client:
-        headers = {"Authorization": f"Bearer {api_key}"}
-        
-        print(f"📤 Uploading {file_path.name}...")
-        
-        with open(file_path, "rb") as f:
-            files = {"file": (file_path.name, f, "application/jsonl")}
-            response = await client.post(
-                f"{MODAL_BASE_URL}/v1/files?purpose=fine-tune",
-                files=files,
-                headers=headers
-            )
-        
-        if response.status_code != 200:
-            raise Exception(f"Failed to upload file: {response.status_code} - {response.text}")
-        
-        file_data = response.json()
-        file_id = file_data["id"]
-        print(f"✅ Uploaded successfully: {file_id}")
-        return file_id
-
-
-async def create_fine_tuning_job(
-    base_model: str,
-    training_file_id: str,
-    suffix: str,
-    hyperparameters: dict,
-    api_key: str,
-    validation_file_id: Optional[str] = None
-) -> str:
-    """Create a fine-tuning job and return the job ID."""
-    async with httpx.AsyncClient(timeout=30.0) as client:
-        headers = {
-            "Authorization": f"Bearer {api_key}",
-            "Content-Type": "application/json"
-        }
-        
-        payload = {
-            "model": base_model,
-            "training_file": training_file_id,
-            "hyperparameters": hyperparameters,
-            "suffix": suffix
-        }
-        
-        if validation_file_id:
-            payload["validation_file"] = validation_file_id
-        
-        print(f"🚀 Creating fine-tuning job...")
-        print(f"   Base model: {base_model}")
-        print(f"   Suffix: {suffix}")
-        print(f"   Hyperparameters: {json.dumps(hyperparameters, indent=2)}")
-        
-        response = await client.post(
-            f"{MODAL_BASE_URL}/v1/fine_tuning/jobs",
-            json=payload,
-            headers=headers
-        )
-        
-        if response.status_code != 200:
-            raise Exception(f"Failed to create job: {response.status_code} - {response.text}")
-        
-        job_data = response.json()
-        job_id = job_data["id"]
-        print(f"✅ Job created: {job_id}")
-        return job_id
-
-
-async def monitor_job(job_id: str, api_key: str) -> dict:
-    """Monitor a fine-tuning job until completion."""
-    async with httpx.AsyncClient(timeout=30.0) as client:
-        headers = {"Authorization": f"Bearer {api_key}"}
-        
-        print(f"\n📊 Monitoring job {job_id}...")
-        
-        while True:
-            # Get job status
-            response = await client.get(
-                f"{MODAL_BASE_URL}/v1/fine_tuning/jobs/{job_id}",
-                headers=headers
-            )
-            
-            if response.status_code != 200:
-                print(f"⚠️  Failed to get job status: {response.text}")
-                await asyncio.sleep(10)
-                continue
-            
-            job_data = response.json()
-            status = job_data["status"]
-            
-            # Print status update
-            print(f"   Status: {status}")
-            
-            # Get recent events
-            events_response = await client.get(
-                f"{MODAL_BASE_URL}/v1/fine_tuning/jobs/{job_id}/events?limit=5",
-                headers=headers
-            )
-            
-            if events_response.status_code == 200:
-                events = events_response.json()["data"]
-                for event in events[:2]:  # Show last 2 events
-                    print(f"   - {event.get('message', 'No message')}")
-            
-            # Check if job is complete
-            if status in ["succeeded", "failed", "cancelled"]:
-                if status == "succeeded":
-                    print(f"\n✅ Fine-tuning completed successfully!")
-                    print(f"   Model ID: {job_data['fine_tuned_model']}")
-                else:
-                    print(f"\n❌ Fine-tuning {status}")
-                    if job_data.get("error"):
-                        print(f"   Error: {job_data['error']}")
-                
-                return job_data
-            
-            # Wait before next check
-            await asyncio.sleep(30)
-
-
-async def validate_training_data(file_path: Path) -> tuple[int, int]:
-    """Validate training data and return (num_examples, num_tokens_estimate)."""
-    num_examples = 0
-    total_chars = 0
-    
-    with open(file_path, "r") as f:
-        for line in f:
-            try:
-                data = json.loads(line)
-                if "messages" in data:
-                    num_examples += 1
-                    # Rough token estimate (chars/4)
-                    total_chars += len(json.dumps(data["messages"]))
-            except json.JSONDecodeError:
-                print(f"⚠️  Invalid JSON line: {line[:50]}...")
-    
-    estimated_tokens = total_chars // 4
-    return num_examples, estimated_tokens
-
-
-async def main():
-    parser = argparse.ArgumentParser(description="Kick off fine-tuning jobs on Modal")
-    parser.add_argument("training_file", type=str, help="Path to training data (JSONL)")
-    parser.add_argument("--base-model", type=str, default="Qwen/Qwen2.5-0.5B-Instruct",
-                       choices=SUPPORTED_MODELS, help="Base model to fine-tune")
-    parser.add_argument("--suffix", type=str, default=None,
-                       help="Model suffix (default: crafter-TIMESTAMP)")
-    parser.add_argument("--epochs", type=int, default=3,
-                       help="Number of training epochs")
-    parser.add_argument("--batch-size", type=int, default=4,
-                       help="Training batch size")
-    parser.add_argument("--learning-rate", type=float, default=2.0,
-                       help="Learning rate multiplier")
-    parser.add_argument("--use-qlora", action="store_true",
-                       help="Enable QLoRA for efficient training")
-    parser.add_argument("--validation-file", type=str, default=None,
-                       help="Optional validation data file")
-    parser.add_argument("--api-key", type=str, default=None,
-                       help="Modal API key (or set MODAL_API_KEY)")
-    parser.add_argument("--no-monitor", action="store_true",
-                       help="Don't monitor job after creation")
-    
-    args = parser.parse_args()
-    
-    # Get API key
-    api_key = args.api_key or os.environ.get("MODAL_API_KEY", MODAL_API_KEY)
-    
-    # Generate suffix if not provided
-    if args.suffix is None:
-        timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
-        args.suffix = f"crafter-{timestamp}"
-    
-    # Validate training file
-    training_path = Path(args.training_file)
-    if not training_path.exists():
-        print(f"❌ Training file not found: {training_path}")
-        return
-    
-    print(f"🔍 Validating training data...")
-    num_examples, est_tokens = await validate_training_data(training_path)
-    print(f"   Examples: {num_examples}")
-    print(f"   Estimated tokens: {est_tokens:,}")
-    
-    if num_examples < 10:
-        print("⚠️  Warning: Very few training examples. Consider generating more data.")
-    
-    # Prepare hyperparameters
-    hyperparams = {
-        "n_epochs": args.epochs,
-        "batch_size": args.batch_size,
-        "learning_rate_multiplier": args.learning_rate,
-        "use_qlora": args.use_qlora
-    }
-    
-    try:
-        # Upload training file
-        training_file_id = await upload_training_file(training_path, api_key)
-        
-        # Upload validation file if provided
-        validation_file_id = None
-        if args.validation_file:
-            val_path = Path(args.validation_file)
-            if val_path.exists():
-                validation_file_id = await upload_training_file(val_path, api_key)
-        
-        # Create fine-tuning job
-        job_id = await create_fine_tuning_job(
-            base_model=args.base_model,
-            training_file_id=training_file_id,
-            suffix=args.suffix,
-            hyperparameters=hyperparams,
-            api_key=api_key,
-            validation_file_id=validation_file_id
-        )
-        
-        # Monitor job unless disabled
-        if not args.no_monitor:
-            job_data = await monitor_job(job_id, api_key)
-            
-            if job_data["status"] == "succeeded":
-                print("\n🎉 Fine-tuning complete!")
-                print(f"Your model is ready: {job_data['fine_tuned_model']}")
-                print("\nTo use your model:")
-                print(f"  curl -X POST {MODAL_BASE_URL}/v1/chat/completions \\")
-                print(f"    -H 'Authorization: Bearer YOUR_API_KEY' \\")
-                print(f"    -H 'Content-Type: application/json' \\")
-                print(f"    -d '{{")
-                print(f'      "model": "{job_data["fine_tuned_model"]}",')
-                print(f'      "messages": [{{"role": "user", "content": "Hello!"}}]')
-                print(f"    }}'")
-        else:
-            print(f"\nJob created: {job_id}")
-            print(f"Check status at: {MODAL_BASE_URL}/v1/fine_tuning/jobs/{job_id}")
-            
-    except Exception as e:
-        print(f"\n❌ Error: {e}")
-        return 1
-    
-    return 0
-
-
-if __name__ == "__main__":
-    asyncio.run(main())