Download scripts/eval_prompt_comparison.py from stmasson/training-scripts: direct link, hf CLI and curl.
- Browser
- Download file 11.5 kB
-
https://huggingface.co/datasets/stmasson/training-scripts/resolve/main/scripts/eval_prompt_comparison.py
- Command line
-
hf download hf://datasets/stmasson/training-scripts/scripts/eval_prompt_comparison.py
-
curl -L -o eval_prompt_comparison.py https://huggingface.co/datasets/stmasson/training-scripts/resolve/main/scripts/eval_prompt_comparison.py
11.5 kB
| # /// 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() | |