""" eval_gemini_batched.py ====================== Evaluate Gemini models on GomParam-v1 via the Gemini API using BATCHING. This drastically speeds up evaluation and bypasses strict daily quotas by evaluating multiple items in a single API request. """ import argparse import csv import json import os import re import time from pathlib import Path 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_batch_prompt(batch: list) -> str: prompt = ( "You are an expert in Goan Konkani linguistics and culture.\n" "Evaluate the following multiple-choice questions.\n" "For each question, select the integer index (0, 1, 2, or 3) of the correct option.\n\n" "CRITICAL INSTRUCTION:\n" f"You MUST output your response as a valid JSON list of exactly {len(batch)} integers. " "Do not include any explanations, markdown formatting, or text outside the JSON list.\n" "Example output: [1, 0, 3, 2]\n\n" "---\n\n" ) for i, item in enumerate(batch): context = item.get("context", "") or item.get("sentence", "") or item.get("passage", "") or "" question = item.get("question", "") or "" candidates = item.get("candidates", []) prompt += f"[Item {i}]\n" if context: prompt += f"Context: {context}\n" if question: prompt += f"Question: {question}\n" else: prompt += "Complete the sentence or identify the correct relation:\n" prompt += "Options:\n" for idx, c in enumerate(candidates): prompt += f"[{idx}] {c}\n" prompt += "\n" return prompt def parse_batch_prediction(text: str, expected_len: int) -> list: """Extracts the JSON list from the response.""" # Strip markdown block if present text = text.strip() if text.startswith("```json"): text = text[7:] if text.startswith("```"): text = text[3:] if text.endswith("```"): text = text[:-3] text = text.strip() try: preds = json.loads(text) if isinstance(preds, list) and len(preds) == expected_len: # Ensure all are valid indices return [int(p) if int(p) in [0, 1, 2, 3] else -1 for p in preds] except json.JSONDecodeError: pass # Fallback regex extraction if JSON fails nums = re.findall(r'\b[0123]\b', text) if len(nums) == expected_len: return [int(n) for n in nums] return [] 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() parser.add_argument("--model", default="gemini-3.1-flash-lite") parser.add_argument("--batch_size", type=int, default=15) parser.add_argument("--delay", type=float, default=4.0) args = parser.parse_args() 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 {args.model}") client = genai.Client(api_key=api_key) config = types.GenerateContentConfig( temperature=0.0, response_mime_type="application/json", ) out_dir = Path("results/gemini/") out_dir.mkdir(parents=True, exist_ok=True) items = load_dataset(Path("data/")) csv_path = out_dir / "predictions.csv" processed_ids = set() module_stats = {} if csv_path.exists(): with open(csv_path, "r", encoding="utf-8") as f: reader = csv.DictReader(f) for row in reader: processed_ids.add(row["id"]) 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"]) unprocessed_items = [it for i, it in enumerate(items) if it.get("id", f"item_{i}") not in processed_ids] print(f"Skipping {len(processed_ids)} already processed items. {len(unprocessed_items)} items remaining.") batches = [unprocessed_items[i:i + args.batch_size] for i in range(0, len(unprocessed_items), args.batch_size)] print(f"Divided into {len(batches)} batches of up to {args.batch_size} items each.") 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 b_idx, batch in enumerate(batches): prompt = build_batch_prompt(batch) max_retries = 5 preds = [] 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() preds = parse_batch_prediction(raw_text, len(batch)) if preds: break # Success else: print(f" Batch {b_idx+1}: Failed to parse JSON, retrying (Attempt {attempt+1}/{max_retries})") time.sleep(2) except Exception as e: error_msg = str(e) if "API_KEY_INVALID" in error_msg or "expired" in error_msg: print(f" API Key INVALID/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 "GenerateRequestsPerDay" in error_msg or wait_time > 60.0: print(f" Hit Daily Quota. Exiting.") return print(f" Rate limited. Waiting {wait_time:.1f}s (Attempt {attempt+1}/{max_retries})") time.sleep(wait_time) else: print(f" API Error on Batch {b_idx+1}: {e}") time.sleep(5) # If all retries failed, log -1 for all items in batch if not preds: print(f" Batch {b_idx+1} completely failed! Assigning -1 to all items.") preds = [-1] * len(batch) # Write results for j, item in enumerate(batch): item_id = item.get("id", f"item_batch_{b_idx}_{j}") mod = item["module"] gold = int(item["correct"]) pred = preds[j] is_correct = int(pred == gold) writer.writerow({ "id": item_id, "module": mod, "correct": gold, "predicted": pred, "predicted_correct": is_correct, "raw_response": f"BATCH_{b_idx+1}" }) if mod not in module_stats: module_stats[mod] = {"correct": 0, "total": 0} module_stats[mod]["correct"] += is_correct module_stats[mod]["total"] += 1 f.flush() print(f" Processed Batch {b_idx+1}/{len(batches)} ({len(batch)} items)") time.sleep(args.delay) print("\nEvaluation Complete! Calculating metrics...") comp_score, comp_weight = 0.0, 0.0 summary = {"model": args.model, "total_items": sum(s["total"] for s in module_stats.values()), "per_module": {}} 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] final_comp = comp_score / comp_weight if comp_weight > 0 else 0.0 summary["composite_accuracy"] = round(final_comp, 4) print(f" Composite Accuracy: {final_comp*100:5.1f}%") summary_path = out_dir / "gemini_summary.json" with open(summary_path, "w", encoding="utf-8") as f: json.dump(summary, f, indent=2) if __name__ == "__main__": main()