Upload scripts/eval_prompt_comparison.py with huggingface_hub

scripts/eval_prompt_comparison.py

@@ -0,0 +1,342 @@
+# /// script
+# dependencies = ["transformers>=4.46.0", "torch", "peft", "bitsandbytes", "accelerate", "datasets", "evalplus", "tqdm", "protobuf", "sentencepiece", "mistral-common>=1.5.0", "huggingface_hub"]
+# ///
+
+"""
+Prompt Comparison: Direct Code vs Reasoning
+Tests if "code only" prompt improves fine-tuned model scores
+
+VERSION: 1.0
+"""
+
+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("PROMPT COMPARISON TEST")
+print("Direct Code vs Reasoning Prompt")
+print("Benchmark: HumanEval")
+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_humaneval():
+    """Load HumanEval dataset from EvalPlus"""
+    print("\nLoading HumanEval dataset...")
+    dataset = load_dataset("evalplus/humanevalplus", 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"""
+    pattern = r'```python\s*(.*?)\s*```'
+    matches = re.findall(pattern, text, re.DOTALL)
+    if matches:
+        return matches[-1].strip()
+
+    pattern = r'```\s*(.*?)\s*```'
+    matches = re.findall(pattern, text, re.DOTALL)
+    if matches:
+        return matches[-1].strip()
+
+    return text.strip()
+
+def generate_direct_prompt(model, tokenizer, prompt):
+    """Generate with DIRECT CODE prompt - no reasoning, just code"""
+    instruct_prompt = f"<s>[INST] Complete this Python function. Output ONLY the function body code, no explanations or markdown:\n\n{prompt}[/INST]"
+
+    inputs = tokenizer(instruct_prompt, return_tensors="pt", truncation=True, max_length=4096).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,
+        )
+
+    raw = tokenizer.decode(outputs[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True)
+    completion = extract_python_code(raw)
+
+    # Extract function body if full function
+    if completion.strip().startswith("def "):
+        lines = completion.split('\n')
+        body_lines = []
+        in_function = False
+        for line in lines:
+            if line.strip().startswith("def "):
+                in_function = True
+                continue
+            if in_function:
+                body_lines.append(line)
+        if body_lines:
+            completion = '\n'.join(body_lines)
+    elif completion == raw.strip():
+        completion = raw
+
+    # Stop at boundaries
+    for stop in ["\ndef ", "\nclass ", "\nif __name__", "\n\n\n"]:
+        if stop in completion:
+            completion = completion[:completion.index(stop)]
+
+    return completion
+
+def generate_reasoning_prompt(model, tokenizer, prompt):
+    """Generate with REASONING prompt - original approach"""
+    instruct_prompt = f"<s>[INST] Solve this programming problem with detailed reasoning:\n\nComplete the following function:\n{prompt}\n[/INST]"
+
+    inputs = tokenizer(instruct_prompt, return_tensors="pt", truncation=True, max_length=4096).to(model.device)
+
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=MAX_NEW_TOKENS * 2,
+            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)
+
+    if "def " in code:
+        lines = code.split('\n')
+        result_lines = []
+        in_function = False
+        for line in lines:
+            if line.strip().startswith("def "):
+                in_function = True
+                continue
+            if in_function:
+                result_lines.append(line)
+        if result_lines:
+            return '\n'.join(result_lines)
+
+    return code
+
+def simple_syntax_check(code):
+    """Basic syntax validation"""
+    try:
+        compile(code, '<string>', 'exec')
+        return True
+    except SyntaxError:
+        return False
+
+def evaluate_samples(samples, dataset):
+    """Evaluate samples"""
+    results = {"passed": 0, "failed": 0, "error": 0}
+
+    for sample in samples:
+        task_id = sample["task_id"]
+        completion = sample["completion"]
+
+        problem = None
+        for p in dataset:
+            if p["task_id"] == task_id:
+                problem = p
+                break
+
+        if problem is None:
+            results["error"] += 1
+            continue
+
+        full_code = problem["prompt"] + completion
+
+        if not simple_syntax_check(full_code):
+            results["failed"] += 1
+            continue
+
+        try:
+            exec_globals = {}
+            exec(full_code, exec_globals)
+            entry_point = problem.get("entry_point", task_id.split("/")[-1])
+            if entry_point in exec_globals:
+                results["passed"] += 1
+            else:
+                results["failed"] += 1
+        except Exception:
+            results["error"] += 1
+
+    total = len(samples)
+    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
+    }
+
+def main():
+    dataset = load_humaneval()
+
+    # Load fine-tuned model
+    print("\n" + "=" * 60)
+    print("LOADING FINE-TUNED MODEL")
+    print("=" * 60)
+    model, tokenizer = load_model(BASE_MODEL, FINETUNED_ADAPTER)
+
+    results = {}
+
+    # Test 1: Direct prompt
+    print("\n" + "=" * 60)
+    print("TEST 1: DIRECT CODE PROMPT")
+    print("'Output ONLY the code, no explanations'")
+    print("=" * 60)
+    direct_samples = []
+    for problem in tqdm(dataset, desc="Direct Prompt"):
+        task_id = problem["task_id"]
+        prompt = problem["prompt"]
+        try:
+            completion = generate_direct_prompt(model, tokenizer, prompt)
+            direct_samples.append({"task_id": task_id, "completion": completion})
+        except Exception as e:
+            print(f"Error on {task_id}: {e}")
+            direct_samples.append({"task_id": task_id, "completion": "# Error"})
+
+    results["direct"] = evaluate_samples(direct_samples, dataset)
+    print(f"\nDirect Prompt Results: pass@1 = {results['direct']['pass@1']*100:.2f}%")
+
+    # Test 2: Reasoning prompt
+    print("\n" + "=" * 60)
+    print("TEST 2: REASONING PROMPT (original)")
+    print("'Solve with detailed reasoning'")
+    print("=" * 60)
+    reasoning_samples = []
+    for problem in tqdm(dataset, desc="Reasoning Prompt"):
+        task_id = problem["task_id"]
+        prompt = problem["prompt"]
+        try:
+            completion = generate_reasoning_prompt(model, tokenizer, prompt)
+            reasoning_samples.append({"task_id": task_id, "completion": completion})
+        except Exception as e:
+            print(f"Error on {task_id}: {e}")
+            reasoning_samples.append({"task_id": task_id, "completion": "# Error"})
+
+    results["reasoning"] = evaluate_samples(reasoning_samples, dataset)
+    print(f"\nReasoning Prompt Results: pass@1 = {results['reasoning']['pass@1']*100:.2f}%")
+
+    # Summary
+    print("\n" + "=" * 60)
+    print("PROMPT COMPARISON SUMMARY - HumanEval")
+    print("=" * 60)
+    print(f"\n{'Prompt Type':<30} {'pass@1':>10} {'Passed':>8} {'Failed':>8}")
+    print("-" * 60)
+    print(f"{'Direct Code Prompt':<30} {results['direct']['pass@1']*100:>9.2f}% {results['direct']['passed']:>8} {results['direct']['failed']:>8}")
+    print(f"{'Reasoning Prompt (original)':<30} {results['reasoning']['pass@1']*100:>9.2f}% {results['reasoning']['passed']:>8} {results['reasoning']['failed']:>8}")
+
+    improvement = (results['direct']['pass@1'] - results['reasoning']['pass@1']) * 100
+    sign = "+" if improvement >= 0 else ""
+    print(f"\n{'Improvement (Direct vs Reasoning):':<30} {sign}{improvement:>9.2f}%")
+
+    # Reference
+    print(f"\n{'Reference - Base Model (v2):':<30} {'82.93%':>10}")
+    print(f"{'Reference - Reasoning (v2):':<30} {'62.20%':>10}")
+
+    # Save results
+    output = {
+        "benchmark": "HumanEval",
+        "experiment": "Prompt Comparison",
+        "model": FINETUNED_ADAPTER,
+        "results": {
+            "direct_prompt": {
+                "pass@1": float(results['direct']['pass@1']),
+                "passed": results['direct']['passed'],
+                "failed": results['direct']['failed'],
+                "total": results['direct']['total']
+            },
+            "reasoning_prompt": {
+                "pass@1": float(results['reasoning']['pass@1']),
+                "passed": results['reasoning']['passed'],
+                "failed": results['reasoning']['failed'],
+                "total": results['reasoning']['total']
+            },
+            "improvement": float(improvement),
+            "base_model_reference": 0.8293,
+            "reasoning_reference": 0.6220
+        },
+        "samples": {
+            "direct": direct_samples[:3],
+            "reasoning": reasoning_samples[:3]
+        }
+    }
+
+    with open("eval_prompt_comparison.json", "w") as f:
+        json.dump(output, f, indent=2)
+    print("\nResults saved to eval_prompt_comparison.json")
+
+    try:
+        api = HfApi()
+        api.upload_file(
+            path_or_fileobj="eval_prompt_comparison.json",
+            path_in_repo="eval_prompt_comparison.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()