training-scripts / scripts /eval_prompt_test.py

Upload scripts/eval_prompt_test.py with huggingface_hub

d66cd5b verified 10 months ago

7.68 kB

# /// script
# dependencies = ["transformers>=4.46.0", "torch", "peft", "bitsandbytes", "accelerate", "datasets", "tqdm", "protobuf", "sentencepiece", "mistral-common>=1.5.0", "huggingface_hub"]
# ///

"""
Prompt Comparison Test: Direct vs Reasoning
Tests if "code only" prompt improves fine-tuned model scores on HumanEval subset
"""

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("=" * 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
NUM_SAMPLES = 50  # Subset for quick test

# 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 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_dataset_subset():
    print("\nLoading HumanEval...")
    ds = load_dataset("openai/openai_humaneval", split="test")
    ds = ds.select(range(min(NUM_SAMPLES, len(ds))))
    print(f"Using {len(ds)} problems")
    return ds

def load_model():
    print(f"\nLoading {BASE_MODEL} + {FINETUNED_ADAPTER}...")

    tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL, trust_remote_code=True)
    if tokenizer.pad_token is None:
        tokenizer.pad_token = tokenizer.eos_token

    model = AutoModelForCausalLM.from_pretrained(
        BASE_MODEL,
        quantization_config=bnb_config,
        device_map="auto",
        trust_remote_code=True,
        torch_dtype=torch.bfloat16,
    )

    model = PeftModel.from_pretrained(model, FINETUNED_ADAPTER)
    model = model.merge_and_unload()
    model.eval()
    print("Model loaded and merged")
    return model, tokenizer

def extract_code(text):
    """Extract Python code from output"""
    # Try ```python blocks
    m = re.findall(r'```python\s*(.*?)\s*```', text, re.DOTALL)
    if m:
        return m[-1].strip()
    # Try ``` blocks
    m = re.findall(r'```\s*(.*?)\s*```', text, re.DOTALL)
    if m:
        return m[-1].strip()
    return text.strip()

def extract_body(code):
    """Extract function body if full function returned"""
    if code.strip().startswith("def "):
        lines = code.split('\n')
        body = []
        in_func = False
        for line in lines:
            if line.strip().startswith("def "):
                in_func = True
                continue
            if in_func:
                body.append(line)
        if body:
            return '\n'.join(body)
    return code

def generate_direct(model, tokenizer, prompt):
    """Direct code prompt - no reasoning"""
    p = f"<s>[INST] Complete this Python function. Output ONLY the code, no explanations:\n\n{prompt}[/INST]"

    inputs = tokenizer(p, return_tensors="pt", truncation=True, max_length=2048).to(model.device)
    with torch.no_grad():
        out = model.generate(
            **inputs,
            max_new_tokens=MAX_NEW_TOKENS,
            temperature=TEMPERATURE,
            do_sample=TEMPERATURE > 0,
            pad_token_id=tokenizer.pad_token_id,
        )

    raw = tokenizer.decode(out[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True)
    code = extract_code(raw)
    code = extract_body(code)

    # Stop at boundaries
    for stop in ["\ndef ", "\nclass ", "\nif __name__"]:
        if stop in code:
            code = code[:code.index(stop)]

    return code

def generate_reasoning(model, tokenizer, prompt):
    """Reasoning prompt - original approach"""
    p = f"<s>[INST] Solve this programming problem with detailed reasoning:\n\n{prompt}[/INST]"

    inputs = tokenizer(p, return_tensors="pt", truncation=True, max_length=2048).to(model.device)
    with torch.no_grad():
        out = model.generate(
            **inputs,
            max_new_tokens=MAX_NEW_TOKENS * 2,
            temperature=TEMPERATURE,
            do_sample=TEMPERATURE > 0,
            pad_token_id=tokenizer.pad_token_id,
        )

    raw = tokenizer.decode(out[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True)
    code = extract_code(raw)
    code = extract_body(code)

    return code

def check_syntax(code):
    try:
        compile(code, '<string>', 'exec')
        return True
    except:
        return False

def evaluate(samples, dataset):
    passed = 0
    total = len(samples)
    ds_dict = {p["task_id"]: p for p in dataset}

    for s in samples:
        task_id = s["task_id"]
        completion = s["completion"]
        problem = ds_dict.get(task_id)
        if not problem:
            continue

        full = problem["prompt"] + completion
        if not check_syntax(full):
            continue

        try:
            g = {}
            exec(full, g)
            entry = problem.get("entry_point", task_id.split("/")[-1])
            if entry in g:
                passed += 1
        except:
            pass

    return {"pass@1": passed / total if total > 0 else 0, "passed": passed, "total": total}

def main():
    dataset = load_dataset_subset()
    model, tokenizer = load_model()

    # Test 1: Direct prompt
    print("\n" + "=" * 60)
    print("TEST 1: DIRECT CODE PROMPT")
    print("=" * 60)
    direct = []
    for p in tqdm(dataset, desc="Direct"):
        try:
            c = generate_direct(model, tokenizer, p["prompt"])
        except:
            c = "# error"
        direct.append({"task_id": p["task_id"], "completion": c})

    r_direct = evaluate(direct, dataset)
    print(f"Direct: {r_direct['pass@1']*100:.1f}% ({r_direct['passed']}/{r_direct['total']})")

    # Test 2: Reasoning prompt
    print("\n" + "=" * 60)
    print("TEST 2: REASONING PROMPT")
    print("=" * 60)
    reasoning = []
    for p in tqdm(dataset, desc="Reasoning"):
        try:
            c = generate_reasoning(model, tokenizer, p["prompt"])
        except:
            c = "# error"
        reasoning.append({"task_id": p["task_id"], "completion": c})

    r_reason = evaluate(reasoning, dataset)
    print(f"Reasoning: {r_reason['pass@1']*100:.1f}% ({r_reason['passed']}/{r_reason['total']})")

    # Summary
    print("\n" + "=" * 60)
    print("RESULTS SUMMARY")
    print("=" * 60)
    print(f"\n{'Prompt':<20} {'pass@1':>10}")
    print("-" * 35)
    print(f"{'Direct Code':<20} {r_direct['pass@1']*100:>9.1f}%")
    print(f"{'Reasoning':<20} {r_reason['pass@1']*100:>9.1f}%")

    diff = (r_direct['pass@1'] - r_reason['pass@1']) * 100
    print(f"\n{'Improvement:':<20} {'+' if diff >= 0 else ''}{diff:.1f}%")

    # Save
    results = {
        "experiment": "Prompt Comparison",
        "samples": NUM_SAMPLES,
        "direct": r_direct,
        "reasoning": r_reason,
        "improvement": diff
    }

    with open("prompt_comparison.json", "w") as f:
        json.dump(results, f, indent=2)

    try:
        api = HfApi()
        api.upload_file(
            path_or_fileobj="prompt_comparison.json",
            path_in_repo="prompt_comparison.json",
            repo_id=OUTPUT_REPO,
            repo_type="model",
        )
        print(f"\nUploaded to {OUTPUT_REPO}")
    except Exception as e:
        print(f"Upload failed: {e}")

    print("\nDONE")

if __name__ == "__main__":
    main()

	# /// script
	# dependencies = ["transformers>=4.46.0", "torch", "peft", "bitsandbytes", "accelerate", "datasets", "tqdm", "protobuf", "sentencepiece", "mistral-common>=1.5.0", "huggingface_hub"]
	# ///

	"""
	Prompt Comparison Test: Direct vs Reasoning
	Tests if "code only" prompt improves fine-tuned model scores on HumanEval subset
	"""

	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("=" * 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
	NUM_SAMPLES = 50 # Subset for quick test

	# 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 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_dataset_subset():
	print("\nLoading HumanEval...")
	ds = load_dataset("openai/openai_humaneval", split="test")
	ds = ds.select(range(min(NUM_SAMPLES, len(ds))))
	print(f"Using {len(ds)} problems")
	return ds

	def load_model():
	print(f"\nLoading {BASE_MODEL} + {FINETUNED_ADAPTER}...")

	tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL, trust_remote_code=True)
	if tokenizer.pad_token is None:
	tokenizer.pad_token = tokenizer.eos_token

	model = AutoModelForCausalLM.from_pretrained(
	BASE_MODEL,
	quantization_config=bnb_config,
	device_map="auto",
	trust_remote_code=True,
	torch_dtype=torch.bfloat16,
	)

	model = PeftModel.from_pretrained(model, FINETUNED_ADAPTER)
	model = model.merge_and_unload()
	model.eval()
	print("Model loaded and merged")
	return model, tokenizer

	def extract_code(text):
	"""Extract Python code from output"""
	# Try ```python blocks
	m = re.findall(r'```python\s(.?)\s*```', text, re.DOTALL)
	if m:
	return m[-1].strip()
	# Try ``` blocks
	m = re.findall(r'```\s(.?)\s*```', text, re.DOTALL)
	if m:
	return m[-1].strip()
	return text.strip()

	def extract_body(code):
	"""Extract function body if full function returned"""
	if code.strip().startswith("def "):
	lines = code.split('\n')
	body = []
	in_func = False
	for line in lines:
	if line.strip().startswith("def "):
	in_func = True
	continue
	if in_func:
	body.append(line)
	if body:
	return '\n'.join(body)
	return code

	def generate_direct(model, tokenizer, prompt):
	"""Direct code prompt - no reasoning"""
	p = f"<s>[INST] Complete this Python function. Output ONLY the code, no explanations:\n\n{prompt}[/INST]"

	inputs = tokenizer(p, return_tensors="pt", truncation=True, max_length=2048).to(model.device)
	with torch.no_grad():
	out = model.generate(
	**inputs,
	max_new_tokens=MAX_NEW_TOKENS,
	temperature=TEMPERATURE,
	do_sample=TEMPERATURE > 0,
	pad_token_id=tokenizer.pad_token_id,
	)

	raw = tokenizer.decode(out[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True)
	code = extract_code(raw)
	code = extract_body(code)

	# Stop at boundaries
	for stop in ["\ndef ", "\nclass ", "\nif __name__"]:
	if stop in code:
	code = code[:code.index(stop)]

	return code

	def generate_reasoning(model, tokenizer, prompt):
	"""Reasoning prompt - original approach"""
	p = f"<s>[INST] Solve this programming problem with detailed reasoning:\n\n{prompt}[/INST]"

	inputs = tokenizer(p, return_tensors="pt", truncation=True, max_length=2048).to(model.device)
	with torch.no_grad():
	out = model.generate(
	**inputs,
	max_new_tokens=MAX_NEW_TOKENS * 2,
	temperature=TEMPERATURE,
	do_sample=TEMPERATURE > 0,
	pad_token_id=tokenizer.pad_token_id,
	)

	raw = tokenizer.decode(out[0][inputs['input_ids'].shape[1]:], skip_special_tokens=True)
	code = extract_code(raw)
	code = extract_body(code)

	return code

	def check_syntax(code):
	try:
	compile(code, '<string>', 'exec')
	return True
	except:
	return False

	def evaluate(samples, dataset):
	passed = 0
	total = len(samples)
	ds_dict = {p["task_id"]: p for p in dataset}

	for s in samples:
	task_id = s["task_id"]
	completion = s["completion"]
	problem = ds_dict.get(task_id)
	if not problem:
	continue

	full = problem["prompt"] + completion
	if not check_syntax(full):
	continue

	try:
	g = {}
	exec(full, g)
	entry = problem.get("entry_point", task_id.split("/")[-1])
	if entry in g:
	passed += 1
	except:
	pass

	return {"pass@1": passed / total if total > 0 else 0, "passed": passed, "total": total}

	def main():
	dataset = load_dataset_subset()
	model, tokenizer = load_model()

	# Test 1: Direct prompt
	print("\n" + "=" * 60)
	print("TEST 1: DIRECT CODE PROMPT")
	print("=" * 60)
	direct = []
	for p in tqdm(dataset, desc="Direct"):
	try:
	c = generate_direct(model, tokenizer, p["prompt"])
	except:
	c = "# error"
	direct.append({"task_id": p["task_id"], "completion": c})

	r_direct = evaluate(direct, dataset)
	print(f"Direct: {r_direct['pass@1']*100:.1f}% ({r_direct['passed']}/{r_direct['total']})")

	# Test 2: Reasoning prompt
	print("\n" + "=" * 60)
	print("TEST 2: REASONING PROMPT")
	print("=" * 60)
	reasoning = []
	for p in tqdm(dataset, desc="Reasoning"):
	try:
	c = generate_reasoning(model, tokenizer, p["prompt"])
	except:
	c = "# error"
	reasoning.append({"task_id": p["task_id"], "completion": c})

	r_reason = evaluate(reasoning, dataset)
	print(f"Reasoning: {r_reason['pass@1']*100:.1f}% ({r_reason['passed']}/{r_reason['total']})")

	# Summary
	print("\n" + "=" * 60)
	print("RESULTS SUMMARY")
	print("=" * 60)
	print(f"\n{'Prompt':<20} {'pass@1':>10}")
	print("-" * 35)
	print(f"{'Direct Code':<20} {r_direct['pass@1']*100:>9.1f}%")
	print(f"{'Reasoning':<20} {r_reason['pass@1']*100:>9.1f}%")

	diff = (r_direct['pass@1'] - r_reason['pass@1']) * 100
	print(f"\n{'Improvement:':<20} {'+' if diff >= 0 else ''}{diff:.1f}%")

	# Save
	results = {
	"experiment": "Prompt Comparison",
	"samples": NUM_SAMPLES,
	"direct": r_direct,
	"reasoning": r_reason,
	"improvement": diff
	}

	with open("prompt_comparison.json", "w") as f:
	json.dump(results, f, indent=2)

	try:
	api = HfApi()
	api.upload_file(
	path_or_fileobj="prompt_comparison.json",
	path_in_repo="prompt_comparison.json",
	repo_id=OUTPUT_REPO,
	repo_type="model",
	)
	print(f"\nUploaded to {OUTPUT_REPO}")
	except Exception as e:
	print(f"Upload failed: {e}")

	print("\nDONE")

	if __name__ == "__main__":
	main()