scripts/eval_gemini.py

"""
eval_gemini.py
==============
Evaluate Gemini models on GomParam-v1 via the Gemini API.
Since APIs do not expose raw log-probabilities, this script uses
a generation-based prompt where the model is asked to output the
index (0, 1, 2, or 3) of the correct answer.

Usage:
  export GEMINI_API_KEY="your_api_key_here"
  python scripts/eval_gemini.py \
    --model gemini-2.5-flash \
    --data_dir data/ \
    --output_dir results/gemini/

Output:
  results/gemini/predictions.csv   — per-item predictions
  results/gemini/summary.json      — per-module and global accuracy
"""

import argparse
import csv
import json
import os
import re
import time
from pathlib import Path

# pip install google-genai
from google import genai
from google.genai import types

def load_dataset(data_dir: Path):
    items = []
    for f in sorted(data_dir.glob("*.json")):
        module = f.stem
        with open(f, encoding="utf-8") as fp:
            data = json.load(fp)
        for it in data:
            it["module"] = module
            items.append(it)
    return items

def build_prompt(item: dict) -> str:
    """Constructs a strict prompt asking for just the integer index."""
    context = item.get("context", "") or item.get("sentence", "") or item.get("passage", "") or ""
    question = item.get("question", "") or ""
    candidates = item.get("candidates", [])
    
    prompt = "You are an expert in Goan Konkani linguistics and culture.\n\n"
    if context:
        prompt += f"Context: {context}\n"
    if question:
        prompt += f"Question: {question}\n\n"
    else:
        prompt += "Complete the sentence or identify the correct relation:\n\n"
        
    prompt += "Options:\n"
    for i, c in enumerate(candidates):
        prompt += f"[{i}] {c}\n"
        
    prompt += "\nOutput ONLY the integer index (0, 1, 2, or 3) of the correct option. Do not provide any explanation."
    return prompt

def extract_prediction(text: str) -> int:
    """Extracts the first number from the model's response."""
    match = re.search(r'\d+', text)
    if match:
        pred = int(match.group())
        if pred in [0, 1, 2, 3]:
            return pred
    return -1 # Invalid prediction

# Module weights (same as standard eval)
MODULE_WEIGHTS = {
    "morphology":0.15, "cloze":0.12, "para_qa":0.10, "idioms_proverbs":0.08,
    "pragmatics":0.08, "cultural_grounding":0.07, "homograph_disambiguation":0.07,
    "entailment":0.06, "coreference":0.06, "register_discrimination":0.05,
    "sentiment":0.04, "spatio_temporal":0.04, "kinship":0.04,
    "numerical_reasoning":0.03, "medical":0.03, "coherence":0.03,
    "cross_scripting":0.02, "code_switching":0.02, "dialect":0.02, "perplexity":0.02,
}
_total_w = sum(MODULE_WEIGHTS.values())
MODULE_WEIGHTS = {k: v / _total_w for k, v in MODULE_WEIGHTS.items()}

def main():
    parser = argparse.ArgumentParser(description="Evaluate Gemini on GomParam-v1")
    parser.add_argument("--model", default="gemini-3.1-flash-lite",
                        help="Gemini model ID (e.g., gemini-3.1-flash-lite, gemini-flash-lite-latest)")
    parser.add_argument("--api_key", default=os.getenv("GEMINI_API_KEY", ""),
                        help="Gemini API Key. Can also use GEMINI_API_KEY env var.")
    parser.add_argument("--data_dir", default="data/", help="Path to GomParam-v1 data directory")
    parser.add_argument("--output_dir", default="results/gemini/", help="Path to save results")
    parser.add_argument("--delay", type=float, default=4.0, help="Delay between API calls to avoid rate limits (4s = 15 RPM)")
    args = parser.parse_args()

    # API Key check bypassed since we are using hardcoded API_KEYS list

    out_dir = Path(args.output_dir)
    out_dir.mkdir(parents=True, exist_ok=True)
    data_dir = Path(args.data_dir)

    api_key = os.getenv("GEMINI_API_KEY")
    if not api_key:
        print("ERROR: GEMINI_API_KEY environment variable is not set!")
        return
        
    print(f"Initializing Gemini Client with model: {args.model}")
    client = genai.Client(api_key=api_key)
    
    # Configure generation to be as strict as possible
    config = types.GenerateContentConfig(
        temperature=0.0,
        max_output_tokens=5, # We only want a single integer
    )

    items = load_dataset(data_dir)
    print(f"Loaded {len(items)} items from {data_dir}")

    rows = []
    module_stats = {}
    
    # Check if resuming from previous run
    csv_path = out_dir / "predictions.csv"
    processed_ids = set()
    if csv_path.exists():
        print(f"Resuming from existing predictions at {csv_path}")
        with open(csv_path, "r", encoding="utf-8") as f:
            reader = csv.DictReader(f)
            for row in reader:
                processed_ids.add(row["id"])
                
                # Rebuild module stats from existing data
                mod = row["module"]
                if mod not in module_stats:
                    module_stats[mod] = {"correct": 0, "total": 0}
                module_stats[mod]["total"] += 1
                module_stats[mod]["correct"] += int(row["predicted_correct"])
                rows.append(row)

    print(f"Starting evaluation... (Skipping {len(processed_ids)} already processed items)")
    
    # Open CSV in append mode if resuming, write mode if starting fresh
    mode = "a" if processed_ids else "w"
    with open(csv_path, mode, newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=["id", "module", "correct", "predicted", "predicted_correct", "raw_response"])
        if not processed_ids:
            writer.writeheader()
            
        for i, item in enumerate(items):
            item_id = item.get("id", f"item_{i}")
            if item_id in processed_ids:
                continue
                
            mod = item["module"]
            gold = int(item["correct"])
            prompt = build_prompt(item)
            
            # API Call with basic retry logic
            max_retries = 5
            pred = -1
            raw_text = ""
            for attempt in range(max_retries):
                try:
                    response = client.models.generate_content(
                        model=args.model,
                        contents=prompt,
                        config=config
                    )
                    raw_text = response.text.strip()
                    pred = extract_prediction(raw_text)
                    break
                except Exception as e:
                    error_msg = str(e)
                    
                    # Handle API Key Invalid or Expired
                    if "API_KEY_INVALID" in error_msg or "expired" in error_msg:
                        print(f"  API Key is INVALID or EXPIRED. Exiting.")
                        return

                    if "429" in error_msg or "RESOURCE_EXHAUSTED" in error_msg:
                        wait_time = 35.0
                        m = re.search(r"retry in (\d+\.?\d*)s", error_msg)
                        if m:
                            wait_time = float(m.group(1)) + 2.0
                            
                        # If daily limit hit, exit
                        if "GenerateRequestsPerDay" in error_msg or wait_time > 60.0:
                            print(f"  Hit Daily Quota. Exiting.")
                            return
                            
                        print(f"  Rate limited on {item_id}. Waiting {wait_time:.1f}s (Attempt {attempt+1}/{max_retries})")
                        time.sleep(wait_time)
                    else:
                        print(f"  API Error on {item_id} (Attempt {attempt+1}/{max_retries}): {e}")
                        time.sleep(5 * (attempt + 1))
            
            is_correct = int(pred == gold)
            
            row = {
                "id": item_id,
                "module": mod,
                "correct": gold,
                "predicted": pred,
                "predicted_correct": is_correct,
                "raw_response": raw_text.replace("\n", " ")
            }
            writer.writerow(row)
            f.flush() # Force write to disk to prevent data loss
            
            if mod not in module_stats:
                module_stats[mod] = {"correct": 0, "total": 0}
            module_stats[mod]["correct"] += is_correct
            module_stats[mod]["total"] += 1
            
            if (i + 1) % 10 == 0:
                print(f"  Processed {i+1}/{len(items)} items. Last pred: {pred} (Gold: {gold})")
                
            time.sleep(args.delay) # Rate limit protection

    print("\nEvaluation Complete! Calculating metrics...")
    
    # Calculate global and module accuracies
    comp_score = 0.0
    comp_weight = 0.0
    
    summary = {
        "model": args.model,
        "total_items": sum(s["total"] for s in module_stats.values()),
        "per_module": {}
    }
    
    print(f"\n{'='*60}")
    print(f"Gemini API Results: {args.model}")
    print(f"{'='*60}")
    
    for mod in sorted(module_stats.keys()):
        st = module_stats[mod]
        acc = st["correct"] / st["total"] if st["total"] > 0 else 0.0
        summary["per_module"][mod] = {
            "accuracy": round(acc, 4),
            "correct": st["correct"],
            "total": st["total"]
        }
        
        if mod in MODULE_WEIGHTS:
            comp_score += acc * MODULE_WEIGHTS[mod]
            comp_weight += MODULE_WEIGHTS[mod]
            
        print(f"  {mod:35s}  {acc*100:5.1f}%  ({st['correct']}/{st['total']})")

    final_comp = comp_score / comp_weight if comp_weight > 0 else 0.0
    summary["composite_accuracy"] = round(final_comp, 4)
    
    print(f"{'-'*60}")
    print(f"  Composite Accuracy:                  {final_comp*100:5.1f}%")
    print(f"{'='*60}")
    
    summary_path = out_dir / "gemini_summary.json"
    with open(summary_path, "w", encoding="utf-8") as f:
        json.dump(summary, f, indent=2)
        
    print(f"Saved summary to {summary_path}")

if __name__ == "__main__":
    main()