Upload scripts/eval_mbpp_hf.py with huggingface_hub

scripts/eval_mbpp_hf.py

@@ -0,0 +1,326 @@
+# /// script
+# dependencies = ["transformers>=4.46.0", "torch", "peft", "bitsandbytes", "accelerate", "datasets", "tqdm", "protobuf", "sentencepiece", "mistral-common>=1.5.0", "huggingface_hub"]
+# ///
+
+"""
+MBPP Evaluation: Base Devstral vs Fine-tuned Alizee-Coder
+Runs on HF Jobs with GPU support
+"""
+
+import os
+import re
+import json
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
+from peft import PeftModel
+from datasets import load_dataset
+from tqdm import tqdm
+from huggingface_hub import HfApi
+
+print("=" * 60)
+print("EVALUATION: Devstral-Small vs Alizee-Coder-Devstral")
+print("Benchmark: MBPP (Mostly Basic Python Problems)")
+print("=" * 60)
+
+# Configuration
+BASE_MODEL = "mistralai/Devstral-Small-2505"
+FINETUNED_ADAPTER = "stmasson/alizee-coder-devstral-1-small"
+OUTPUT_REPO = "stmasson/alizee-coder-devstral-1-small"
+TEMPERATURE = 0.1
+MAX_NEW_TOKENS = 512
+
+# Check GPU
+print(f"\nGPU available: {torch.cuda.is_available()}")
+if torch.cuda.is_available():
+    print(f"GPU: {torch.cuda.get_device_name(0)}")
+    print(f"Memory: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB")
+
+# 4-bit quantization config
+bnb_config = BitsAndBytesConfig(
+    load_in_4bit=True,
+    bnb_4bit_quant_type="nf4",
+    bnb_4bit_compute_dtype=torch.bfloat16,
+    bnb_4bit_use_double_quant=True,
+)
+
+def load_mbpp():
+    """Load MBPP dataset"""
+    print("\nLoading MBPP dataset...")
+    # Load the sanitized version (cleaner test cases)
+    dataset = load_dataset("google-research-datasets/mbpp", "sanitized", split="test")
+    print(f"Loaded {len(dataset)} problems")
+    return dataset
+
+def load_model(model_name, adapter_name=None):
+    """Load model with optional LoRA adapter"""
+    print(f"\nLoading model: {model_name}")
+    if adapter_name:
+        print(f"With adapter: {adapter_name}")
+
+    tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
+    if tokenizer.pad_token is None:
+        tokenizer.pad_token = tokenizer.eos_token
+
+    model = AutoModelForCausalLM.from_pretrained(
+        model_name,
+        quantization_config=bnb_config,
+        device_map="auto",
+        trust_remote_code=True,
+        torch_dtype=torch.bfloat16,
+    )
+
+    if adapter_name:
+        print("Loading LoRA adapter...")
+        model = PeftModel.from_pretrained(model, adapter_name)
+        model = model.merge_and_unload()
+        print("Adapter merged")
+
+    model.eval()
+    return model, tokenizer
+
+def extract_python_code(text):
+    """Extract Python code from model output"""
+    # Try ```python blocks
+    pattern = r'```python\s*(.*?)\s*```'
+    matches = re.findall(pattern, text, re.DOTALL)
+    if matches:
+        return matches[-1].strip()
+
+    # Try ``` blocks
+    pattern = r'```\s*(.*?)\s*```'
+    matches = re.findall(pattern, text, re.DOTALL)
+    if matches:
+        return matches[-1].strip()
+
+    return text.strip()
+
+def generate_completion_base(model, tokenizer, prompt):
+    """Generate code completion for BASE model (direct completion)"""
+    # For base model, use a simple completion format
+    code_prompt = f"# Python function\n{prompt}\n\ndef"
+
+    inputs = tokenizer(code_prompt, return_tensors="pt", truncation=True, max_length=2048).to(model.device)
+
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=MAX_NEW_TOKENS,
+            temperature=TEMPERATURE,
+            do_sample=True if TEMPERATURE > 0 else False,
+            pad_token_id=tokenizer.pad_token_id,
+            eos_token_id=tokenizer.eos_token_id,
+        )
+
+    completion = tokenizer.decode(outputs[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True)
+
+    # Reconstruct the function
+    full_code = "def" + completion
+
+    # Stop at function boundary
+    stop_tokens = ["\ndef ", "\nclass ", "\nif __name__", "\n\n\n"]
+    for stop in stop_tokens:
+        if stop in full_code:
+            full_code = full_code[:full_code.index(stop)]
+
+    return full_code
+
+def generate_completion_finetuned(model, tokenizer, prompt):
+    """Generate code completion for FINE-TUNED model (Instruct format)"""
+    instruct_prompt = f"<s>[INST] Solve this programming problem with detailed reasoning:\n\n{prompt}\n[/INST]"
+
+    inputs = tokenizer(instruct_prompt, return_tensors="pt", truncation=True, max_length=2048).to(model.device)
+
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=MAX_NEW_TOKENS * 2,  # More tokens for reasoning
+            temperature=TEMPERATURE,
+            do_sample=True if TEMPERATURE > 0 else False,
+            pad_token_id=tokenizer.pad_token_id,
+            eos_token_id=tokenizer.eos_token_id,
+        )
+
+    full_response = tokenizer.decode(outputs[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True)
+    code = extract_python_code(full_response)
+
+    return code
+
+def evaluate_model(model, tokenizer, dataset, model_name, is_finetuned=False):
+    """Evaluate model on MBPP"""
+    print(f"\nEvaluating {model_name}...")
+    samples = []
+
+    for i, problem in enumerate(tqdm(dataset, desc=f"Generating ({model_name})")):
+        task_id = problem.get("task_id", i)
+        prompt = problem["prompt"]  # Natural language description
+
+        try:
+            if is_finetuned:
+                completion = generate_completion_finetuned(model, tokenizer, prompt)
+            else:
+                completion = generate_completion_base(model, tokenizer, prompt)
+
+            samples.append({
+                "task_id": task_id,
+                "prompt": prompt[:200],
+                "completion": completion,
+                "test_list": problem.get("test_list", []),
+                "model": model_name
+            })
+        except Exception as e:
+            print(f"Error on task {task_id}: {e}")
+            samples.append({
+                "task_id": task_id,
+                "prompt": prompt[:200],
+                "completion": "# Error during generation",
+                "test_list": problem.get("test_list", []),
+                "model": model_name
+            })
+
+    return samples
+
+def run_tests(code, test_list):
+    """Run test cases on generated code"""
+    try:
+        # Create execution environment
+        exec_globals = {}
+        exec(code, exec_globals)
+
+        # Run each test
+        for test in test_list:
+            try:
+                exec(test, exec_globals)
+            except AssertionError:
+                return False
+            except Exception:
+                return False
+        return True
+    except Exception:
+        return False
+
+def evaluate_samples(samples):
+    """Evaluate samples by running test cases"""
+    results = {"passed": 0, "failed": 0, "error": 0}
+    detailed = []
+
+    for sample in samples:
+        task_id = sample["task_id"]
+        code = sample["completion"]
+        test_list = sample.get("test_list", [])
+
+        if not test_list:
+            results["error"] += 1
+            detailed.append({"task_id": task_id, "status": "no_tests"})
+            continue
+
+        # Try to run the tests
+        if run_tests(code, test_list):
+            results["passed"] += 1
+            detailed.append({"task_id": task_id, "status": "passed"})
+        else:
+            results["failed"] += 1
+            detailed.append({"task_id": task_id, "status": "failed"})
+
+    total = results["passed"] + results["failed"]
+    pass_rate = results["passed"] / total if total > 0 else 0
+
+    return {
+        "pass@1": pass_rate,
+        "passed": results["passed"],
+        "failed": results["failed"],
+        "error": results["error"],
+        "total": total,
+        "detailed": detailed[:10]
+    }
+
+def main():
+    # Load dataset
+    dataset = load_mbpp()
+
+    results = {}
+
+    # Evaluate base model
+    print("\n" + "=" * 60)
+    print("EVALUATING BASE MODEL")
+    print("=" * 60)
+    base_model, base_tokenizer = load_model(BASE_MODEL)
+    base_samples = evaluate_model(base_model, base_tokenizer, dataset, "Devstral-Small-Base", is_finetuned=False)
+    results["base"] = evaluate_samples(base_samples)
+    print(f"\nBase Model Results: pass@1 = {results['base']['pass@1']*100:.2f}%")
+
+    # Free memory
+    del base_model
+    torch.cuda.empty_cache()
+
+    # Evaluate fine-tuned model
+    print("\n" + "=" * 60)
+    print("EVALUATING FINE-TUNED MODEL")
+    print("=" * 60)
+    ft_model, ft_tokenizer = load_model(BASE_MODEL, FINETUNED_ADAPTER)
+    ft_samples = evaluate_model(ft_model, ft_tokenizer, dataset, "Alizee-Coder-Devstral", is_finetuned=True)
+    results["finetuned"] = evaluate_samples(ft_samples)
+    print(f"\nFine-tuned Model Results: pass@1 = {results['finetuned']['pass@1']*100:.2f}%")
+
+    # Summary
+    print("\n" + "=" * 60)
+    print("COMPARISON SUMMARY - MBPP")
+    print("=" * 60)
+    print(f"\n{'Model':<40} {'pass@1':>10} {'Passed':>8} {'Failed':>8}")
+    print("-" * 70)
+    print(f"{'Devstral-Small-2505 (Base)':<40} {results['base']['pass@1']*100:>9.2f}% {results['base']['passed']:>8} {results['base']['failed']:>8}")
+    print(f"{'Alizee-Coder-Devstral (Fine-tuned)':<40} {results['finetuned']['pass@1']*100:>9.2f}% {results['finetuned']['passed']:>8} {results['finetuned']['failed']:>8}")
+
+    improvement = (results['finetuned']['pass@1'] - results['base']['pass@1']) * 100
+    sign = "+" if improvement >= 0 else ""
+    print(f"\n{'Improvement:':<40} {sign}{improvement:>9.2f}%")
+
+    # Save results
+    output = {
+        "benchmark": "MBPP",
+        "base_model": BASE_MODEL,
+        "finetuned_model": FINETUNED_ADAPTER,
+        "results": {
+            "base": {
+                "pass@1": float(results['base']['pass@1']),
+                "passed": results['base']['passed'],
+                "failed": results['base']['failed'],
+                "total": results['base']['total']
+            },
+            "finetuned": {
+                "pass@1": float(results['finetuned']['pass@1']),
+                "passed": results['finetuned']['passed'],
+                "failed": results['finetuned']['failed'],
+                "total": results['finetuned']['total']
+            },
+            "improvement": float(improvement)
+        },
+        "samples": {
+            "base": base_samples[:5],
+            "finetuned": ft_samples[:5]
+        }
+    }
+
+    # Save locally
+    with open("eval_results_mbpp.json", "w") as f:
+        json.dump(output, f, indent=2)
+    print("\nResults saved to eval_results_mbpp.json")
+
+    # Upload results
+    try:
+        api = HfApi()
+        api.upload_file(
+            path_or_fileobj="eval_results_mbpp.json",
+            path_in_repo="eval_results_mbpp.json",
+            repo_id=OUTPUT_REPO,
+            repo_type="model",
+        )
+        print(f"Results uploaded to {OUTPUT_REPO}")
+    except Exception as e:
+        print(f"Could not upload results: {e}")
+
+    print("\n" + "=" * 60)
+    print("EVALUATION COMPLETE")
+    print("=" * 60)
+
+if __name__ == "__main__":
+    main()