synth-ai 0.2.4.dev8__py3-none-any.whl → 0.2.4.dev9__py3-none-any.whl

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

@@ -0,0 +1,150 @@
+```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

@@ -0,0 +1,283 @@
+#!/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())