Upload scripts/eval_humaneval_v3_lite.py with huggingface_hub

scripts/eval_humaneval_v3_lite.py

@@ -0,0 +1,336 @@
+# /// script
+# dependencies = ["transformers>=4.46.0", "torch", "peft", "bitsandbytes", "accelerate", "datasets", "tqdm", "huggingface_hub"]
+# ///
+
+"""
+HumanEval Evaluation v3 LITE: Direct Code Prompt
+Reduced dependencies, minimal storage usage
+"""
+
+import os
+import re
+import json
+import gc
+
+# Reduce cache usage
+os.environ["TRANSFORMERS_CACHE"] = "/tmp/hf_cache"
+os.environ["HF_HOME"] = "/tmp/hf_home"
+os.environ["HF_HUB_CACHE"] = "/tmp/hf_cache"
+
+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 v3 LITE: Direct Code Prompt Test")
+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"""
+    print("\nLoading HumanEval dataset...")
+    dataset = load_dataset("openai/openai_humaneval", 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,
+        low_cpu_mem_usage=True,
+    )
+
+    if adapter_name:
+        print("Loading LoRA adapter...")
+        model = PeftModel.from_pretrained(model, adapter_name)
+        model = model.merge_and_unload()
+        print("Adapter merged")
+
+    model.eval()
+
+    # Clear cache after loading
+    gc.collect()
+    torch.cuda.empty_cache()
+
+    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_direct(model, tokenizer, prompt):
+    """Generate code with DIRECT CODE prompt (no reasoning)"""
+    instruct_prompt = f"""<s>[INST] Complete this Python function. Output ONLY the function body code, no explanations:
+
+{prompt}[/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,
+            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_completion = tokenizer.decode(outputs[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True)
+    completion = extract_python_code(raw_completion)
+
+    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_completion.strip():
+        completion = raw_completion
+
+    stop_tokens = ["\ndef ", "\nclass ", "\nif __name__", "\n\n\n"]
+    for stop in stop_tokens:
+        if stop in completion:
+            completion = completion[:completion.index(stop)]
+
+    return completion
+
+def generate_completion_reasoning(model, tokenizer, prompt):
+    """Generate code with REASONING prompt (original approach)"""
+    instruct_prompt = f"""<s>[INST] Solve this programming problem with detailed reasoning:
+
+Complete the following function:
+{prompt}[/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,
+            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}
+
+    dataset_dict = {p["task_id"]: p for p in dataset}
+
+    for sample in samples:
+        task_id = sample["task_id"]
+        completion = sample["completion"]
+
+        problem = dataset_dict.get(task_id)
+        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 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("=" * 60)
+    direct_samples = []
+    for problem in tqdm(dataset, desc="Direct Prompt"):
+        try:
+            completion = generate_completion_direct(model, tokenizer, problem["prompt"])
+            direct_samples.append({
+                "task_id": problem["task_id"],
+                "completion": completion,
+            })
+        except Exception as e:
+            direct_samples.append({
+                "task_id": problem["task_id"],
+                "completion": "# Error",
+            })
+    results["direct"] = evaluate_samples(direct_samples, dataset)
+    print(f"\nDirect Prompt: pass@1 = {results['direct']['pass@1']*100:.2f}%")
+
+    # Test 2: Reasoning prompt
+    print("\n" + "=" * 60)
+    print("TEST 2: REASONING PROMPT")
+    print("=" * 60)
+    reasoning_samples = []
+    for problem in tqdm(dataset, desc="Reasoning Prompt"):
+        try:
+            completion = generate_completion_reasoning(model, tokenizer, problem["prompt"])
+            reasoning_samples.append({
+                "task_id": problem["task_id"],
+                "completion": completion,
+            })
+        except Exception as e:
+            reasoning_samples.append({
+                "task_id": problem["task_id"],
+                "completion": "# Error",
+            })
+    results["reasoning"] = evaluate_samples(reasoning_samples, dataset)
+    print(f"\nReasoning Prompt: pass@1 = {results['reasoning']['pass@1']*100:.2f}%")
+
+    # Summary
+    print("\n" + "=" * 60)
+    print("PROMPT COMPARISON - HumanEval")
+    print("=" * 60)
+    print(f"\n{'Prompt Type':<25} {'pass@1':>10} {'Passed':>8} {'Failed':>8}")
+    print("-" * 55)
+    print(f"{'Direct Code':<25} {results['direct']['pass@1']*100:>9.2f}% {results['direct']['passed']:>8} {results['direct']['failed']:>8}")
+    print(f"{'Reasoning':<25} {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:':<25} {sign}{improvement:>9.2f}%")
+    print(f"{'Base Model Reference:':<25} {'82.93%':>10}")
+
+    # Save
+    output = {
+        "benchmark": "HumanEval",
+        "experiment": "Prompt Comparison",
+        "results": {
+            "direct": results["direct"],
+            "reasoning": results["reasoning"],
+            "improvement": float(improvement)
+        }
+    }
+
+    with open("eval_prompt_comparison.json", "w") as f:
+        json.dump(output, f, indent=2)
+
+    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"\nResults uploaded to {OUTPUT_REPO}")
+    except Exception as e:
+        print(f"Could not upload: {e}")
+
+    print("\n" + "=" * 60)
+    print("EVALUATION COMPLETE")
+    print("=" * 60)
+
+if __name__ == "__main__":
+    main()