Clean upload with all adapters

.gitattributes

@@ -0,0 +1,4 @@
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.json filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,2 @@
+checkpoint-*
+runs/

README.md

@@ -0,0 +1,36 @@
+# GG Team Instruction-Tuned Adapters (LLaMA 3.2-3B)
+
+This repository provides a collection of PEFT adapters (LoRA) trained on various instruction-tuning datasets using the base model **LLaMA 3.2-3B**. These adapters are developed by **GG Team - CSE476 @ Arizona State University**.
+
+## Adapter Variants
+
+| Folder | Dataset(s) Used | Description |
+|--------|------------------|-------------|
+| `llama-3.2-3B-sft` | Alpaca | Fine-tuned only on the original Alpaca dataset |
+| `llama-3.2-3B-sft-dolly` | Alpaca + Dolly | Fine-tuned on Databricks' Dolly dataset |
+| `llama-3.2-3B-sft-FLAN` | Alpaca + Dolly + FLAN | Fine-tuned on FLAN and Alpaca mixed |
+| `sft_a_d` | Alpaca + Dolly | Combined dataset fine-tuning (Alpaca + Dolly) |
+| `sft_a_d1` | Alpaca(cleaned) + Dolly | Combined dataset fine-tuning (Alpaca + Dolly) |
+
+---
+
+## 🛠️ Usage (with `peft`)
+
+Here's an example of loading one of the adapters using 🤗 Transformers and PEFT:
+
+```python
+from peft import PeftModel
+from transformers import AutoTokenizer, AutoModelForCausalLM
+
+# Load base model
+base_model = AutoModelForCausalLM.from_pretrained("meta-llama/Meta-Llama-3-3B")
+tokenizer = AutoTokenizer.from_pretrained("meta-llama/Meta-Llama-3-3B")
+
+# Load adapter (choose one)
+model = PeftModel.from_pretrained(base_model, "gg-cse476/gg/sft_a_d")
+
+# Inference
+prompt = "Explain how a rocket works in simple terms."
+inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+outputs = model.generate(**inputs, max_new_tokens=100)
+print(tokenizer.decode(outputs[0], skip_special_tokens=True))

adapter_config.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a397f1a6ee965478e249f2b6142ac0da696267baaca2dc9446d1e104bc8d5d21
+size 856

adapter_model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b9c181229a5f1c9a089843e7c619927962920a711def219f9b83a1c5ea9e28ef
+size 97307544

ajay.py

@@ -0,0 +1,138 @@
+import sys
+import os
+
+# Add the parent directory to the path so Backend can be imported
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from datasets import load_dataset
+import torch
+import numpy as np
+import json
+import time
+from tqdm import tqdm
+from model import Load_model
+
+# === Step 1: Load CodeAlpaca Data ===
+def load_benchmark_data_codealpaca(num_samples=20):
+    """Load the CodeAlpaca-20k instruction-tuning dataset."""
+    dataset = load_dataset("sahil2801/CodeAlpaca-20k")["train"]
+    if num_samples and num_samples < len(dataset):
+        indices = np.random.choice(len(dataset), num_samples, replace=False)
+        dataset = dataset.select(indices)
+    return dataset
+
+# === Step 2: Generate Solutions (and collect reference) ===
+def generate_solutions_codealpaca(model, tokenizer, dataset, max_tokens=512):
+    """
+    Generate code for each CodeAlpaca instruction.
+    Returns a list of dicts with problem_id, prompt, generated_code, reference, generation_time.
+    """
+    results = []
+    prompt_template = "### Instruction:\n{}\n\n### Response:\n"
+    
+    for item in tqdm(dataset, desc="Generating CodeAlpaca solutions"):
+        instruction = item["instruction"]
+        reference = item["output"]
+        
+        prompt = prompt_template.format(instruction)
+        
+        # derive a safe problem_id from first 50 chars of instruction
+        raw_id = instruction.strip().replace("\n", " ")
+        problem_id = raw_id[:50].replace(" ", "_").replace("/", "_")
+        
+        # generation
+        start_time = time.time()
+        inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+        with torch.no_grad():
+            output = model.generate(
+                **inputs,
+                max_length=max_tokens,
+                do_sample=True,
+                temperature=0.2,
+                top_p=0.95,
+                pad_token_id=tokenizer.eos_token_id
+            )
+        generation_time = time.time() - start_time
+        
+        generated = tokenizer.decode(output[0], skip_special_tokens=True)
+        # strip the prompt prefix from the generation
+        if generated.startswith(prompt):
+            generated = generated[len(prompt):]
+        
+        results.append({
+            "problem_id": problem_id,
+            "prompt": prompt,
+            "generated_code": generated,
+            "reference": reference,
+            "generation_time": generation_time
+        })
+    return results
+
+# === Step 3: Evaluate Solutions by Exact-Match ===
+def evaluate_solutions_codealpaca(solutions):
+    """
+    Count how many generations exactly match the reference.
+    Returns total, correct_count, pass_rate, plus all details.
+    """
+    total = len(solutions)
+    correct_count = sum(
+        1 for s in solutions
+        if s["generated_code"].strip() == s["reference"].strip()
+    )
+    pass_rate = correct_count / total if total > 0 else 0.0
+    
+    return {
+        "total": total,
+        "correct_count": correct_count,
+        "pass_rate": pass_rate,
+        "detailed_results": solutions
+    }
+
+# === Step 4: Save Results ===
+def save_evaluation_results_codealpaca(model_name, results, solutions):
+    """Save summary (with pass_rate) and detailed generations to JSON files."""
+    results_dir = "code_evaluation_results"
+    os.makedirs(results_dir, exist_ok=True)
+    
+    summary = {
+        "model": model_name,
+        "benchmark": "codealpaca",
+        "total_examples": results["total"],
+        "correct_count": results["correct_count"],
+        "pass_rate": results["pass_rate"],
+        "avg_generation_time": float(np.mean([s["generation_time"] for s in solutions]))
+    }
+    
+    summary_file = os.path.join(results_dir, f"{model_name}_codealpaca_summary.json")
+    detailed_file = os.path.join(results_dir, f"{model_name}_codealpaca_detailed.json")
+    
+    with open(summary_file, "w") as f:
+        json.dump(summary, f, indent=4)
+    with open(detailed_file, "w") as f:
+        json.dump(results["detailed_results"], f, indent=4)
+    
+    print(f"Saved summary to {summary_file}")
+    print(f"Saved detailed outputs to {detailed_file}")
+    return summary_file, detailed_file
+
+# === Step 5: Run the CodeAlpaca Evaluation ===
+def run_codealpaca_evaluation(model_name, num_samples=20):
+    loader = Load_model("gg-cse476/gg-step2000")
+    model, tokenizer = loader.get()
+    
+    dataset = load_benchmark_data_codealpaca(num_samples)
+    solutions = generate_solutions_codealpaca(model, tokenizer, dataset)
+    results = evaluate_solutions_codealpaca(solutions)
+    save_evaluation_results_codealpaca(model_name, results, solutions)
+    
+    return results
+
+if __name__ == "__main__":
+    model_name = "Llama-3-SFT"
+    # e.g. evaluate on 20 random CodeAlpaca examples
+    results = run_codealpaca_evaluation(model_name=model_name, num_samples=20)
+    
+    print("\n=== CodeAlpaca Evaluation Summary ===")
+    print(f"Total examples   : {results['total']}")
+    print(f"Correct (exact)  : {results['correct_count']}")
+    print(f"Pass@1 (exact)   : {results['pass_rate']:.2%}")

special_tokens_map.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:849070cae53bd45439e64ce5b1ddd650a66081b1bd47895c5a58939a05055579
+size 335

tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:52716f60c3ad328509fa37cdded9a2f1196ecae463f5480f5d38c66a25e7a7dc
+size 17210019

tokenizer_config.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fb0b184bfd935cbe6f8290f1af424c17814fd24dfc5aaac3be9b0b674fe40631
+size 50560

training_args.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab0d3f35c51da985f6c4b5c45b6b6b5eeb42eafaf2e6d58a442c1a853e20f24e
+size 5304