Add training and evaluation scripts

scripts/README.md

@@ -0,0 +1,29 @@
+# Finetune + Eval Scripts
+
+Scripts used to train and evaluate the adapters in this repo.
+
+## Environment
+```bash
+python3 -m venv /home/ai/llama-finetune-env
+/home/ai/llama-finetune-env/bin/pip install torch transformers accelerate peft bitsandbytes trl datasets huggingface_hub
+```
+
+GPU note: GPU 0 is occupied by vLLM; both scripts pin `CUDA_VISIBLE_DEVICES=1`.
+
+## Programming model (this repo)
+- `programming_finetune_aggressive.py` — trains `rishini/qwen2.5-coder-7b-programming-lora`
+  - Base: `Qwen/Qwen2.5-Coder-7B-Instruct`, LoRA r=64 alpha=128, 6k filtered CodeAlpaca examples, 3 epochs, completion-only masking.
+  - Output dir: `/home/ai/qwen-coder-programming-best`
+- `eval_best_model.py` — held-out evaluation prompts, loads the adapter from `/home/ai/qwen-coder-programming-best`.
+
+## Security model (other work)
+- `security_finetune.py` — CodeLlama-7B-Instruct + LoRA for vulnerability analysis.
+  - Base: `codellama/CodeLlama-7b-Instruct-hf`, output dir: `/home/ai/codellama-security-finetuned`
+- `test_security_model.py` — runs the security adapter on sample vulnerable snippets.
+
+## Run
+```bash
+cd /home/ai
+/home/ai/llama-finetune-env/bin/python programming_finetune_aggressive.py   # train
+/home/ai/llama-finetune-env/bin/python eval_best_model.py                    # eval
+```

scripts/eval_best_model.py

@@ -0,0 +1,54 @@
+import os
+os.environ["CUDA_VISIBLE_DEVICES"] = "1"
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
+from peft import PeftModel
+
+BASE_MODEL = "Qwen/Qwen2.5-Coder-7B-Instruct"
+ADAPTER_PATH = "/home/ai/qwen-coder-programming-best"
+
+def load_model():
+    bnb_config = BitsAndBytesConfig(
+        load_in_4bit=True, bnb_4bit_quant_type="nf4",
+        bnb_4bit_compute_dtype=torch.bfloat16, bnb_4bit_use_double_quant=True,
+    )
+    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, ADAPTER_PATH)
+    tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL, trust_remote_code=True, use_fast=True)
+    tokenizer.pad_token = tokenizer.eos_token
+    return model, tokenizer
+
+def generate(model, tokenizer, prompt):
+    messages = [{"role": "user", "content": prompt}]
+    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    inputs = tokenizer(text, return_tensors="pt").to(model.device)
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs, max_new_tokens=512, temperature=0.2, top_p=0.9,
+            do_sample=True, repetition_penalty=1.05, pad_token_id=tokenizer.pad_token_id,
+        )
+    return tokenizer.decode(outputs[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True)
+
+HELD_OUT = [
+    "Write a Python function to find the longest common prefix among a list of strings.",
+    "Implement a min-heap in Python from scratch without using the heapq module.",
+    "Write a Python function that performs topological sort on a directed acyclic graph represented as an adjacency list.",
+    "Write a Python function to serialize and deserialize a binary tree using a queue-based BFS approach.",
+    "Implement a Python function that finds all palindromic substrings of a given string.",
+    "Write Python code using the sliding window technique to find the longest substring without repeating characters.",
+]
+
+def main():
+    model, tokenizer = load_model()
+    for t in HELD_OUT:
+        print("=" * 64)
+        print("PROMPT:", t)
+        print("-" * 64)
+        print(generate(model, tokenizer, t))
+        print()
+
+if __name__ == "__main__":
+    main()

scripts/programming_finetune.py

@@ -0,0 +1,146 @@
+import os
+os.environ["CUDA_VISIBLE_DEVICES"] = "1"
+
+import torch
+from datasets import Dataset
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    TrainingArguments,
+    Trainer,
+    DataCollatorForLanguageModeling,
+    BitsAndBytesConfig,
+)
+from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training, TaskType
+
+MODEL_NAME = "Qwen/Qwen2.5-Coder-7B-Instruct"
+OUTPUT_DIR = "/home/ai/qwen-coder-programming-finetuned"
+
+PROG_DATA = [
+    {"system": "You are an expert software engineer. Write clean, correct, efficient code.", "prompt": "Write a Python function to check if a string is a valid palindrome ignoring case and non-alphanumeric characters.", "output": "```python\ndef is_palindrome(s: str) -> bool:\n    cleaned = ''.join(c.lower() for c in s if c.isalnum())\n    return cleaned == cleaned[::-1]\n```\n\nTime: O(n), Space: O(n). Returns True for 'A man, a plan, a canal: Panama'."},
+    {"system": "You are an expert software engineer. Write clean, correct, efficient code.", "prompt": "Write a Python function using a binary search to find the index of a target in a sorted list, or -1 if not present.", "output": "```python\ndef binary_search(arr, target):\n    low, high = 0, len(arr) - 1\n    while low <= high:\n        mid = (low + high) // 2\n        if arr[mid] == target:\n            return mid\n        elif arr[mid] < target:\n            low = mid + 1\n        else:\n            high = mid - 1\n    return -1\n```\n\nTime: O(log n), Space: O(1)." },
+    {"system": "You are an expert software engineer. Write clean, correct, efficient code.", "prompt": "Write a Python function that returns the nth Fibonacci number using dynamic programming with memoization.", "output": "```python\nfrom functools import lru_cache\n\ndef fib(n: int) -> int:\n    @lru_cache(maxsize=None)\n    def _fib(n: int) -> int:\n        if n < 2:\n            return n\n        return _fib(n - 1) + _fib(n - 2)\n    return _fib(n)\n```\n\nTime: O(n), Space: O(n). Using lru_cache avoids exponential recomputation."},
+    {"system": "You are an expert software engineer. Write clean, correct, efficient code.", "prompt": "Write a Python class implementing a simple LRU cache with get and put operations in O(1).", "output": "```python\nfrom collections import OrderedDict\n\nclass LRUCache:\n    def __init__(self, capacity: int):\n        self.capacity = capacity\n        self.cache = OrderedDict()\n\n    def get(self, key: int) -> int:\n        if key not in self.cache:\n            return -1\n        self.cache.move_to_end(key)\n        return self.cache[key]\n\n    def put(self, key: int, value: int) -> None:\n        if key in self.cache:\n            self.cache.move_to_end(key)\n        self.cache[key] = value\n        if len(self.cache) > self.capacity:\n            self.cache.popitem(last=False)\n```\n\nBoth operations are O(1) using OrderedDict."},
+    {"system": "You are an expert software engineer. Write clean, correct, efficient code.", "prompt": "Write a Python function to merge two sorted lists into one sorted list.", "output": "```python\ndef merge_sorted(a, b):\n    result = []\n    i = j = 0\n    while i < len(a) and j < len(b):\n        if a[i] <= b[j]:\n            result.append(a[i]); i += 1\n        else:\n            result.append(b[j]); j += 1\n    result.extend(a[i:])\n    result.extend(b[j:])\n    return result\n```\n\nTime: O(n + m), Space: O(n + m)." },
+    {"system": "You are an expert software engineer. Write clean, correct, efficient code.", "prompt": "Write a Python function using a trie to find if a word exists in a set of words.", "output": "```python\nclass TrieNode:\n    def __init__(self):\n        self.children = {}\n        self.is_word = False\n\ndef build_trie(words):\n    root = TrieNode()\n    for w in words:\n        node = root\n        for ch in w:\n            node = node.children.setdefault(ch, TrieNode())\n        node.is_word = True\n    return root\n\ndef exists(trie, word):\n    node = trie\n    for ch in word:\n        if ch not in node.children:\n            return False\n        node = node.children[ch]\n    return node.is_word\n```\n\nInsert and search are O(len(word))."},
+    {"system": "You are an expert software engineer. Write clean, correct, efficient code.", "prompt": "Write a Python function that reverses a linked list in place.", "output": "```python\ndef reverse_linked_list(head):\n    prev = None\n    curr = head\n    while curr:\n        nxt = curr.next\n        curr.next = prev\n        prev = curr\n        curr = nxt\n    return prev\n```\n\nIterative approach, O(n) time, O(1) space."},
+    {"system": "You are an expert software engineer. Write clean, correct, efficient code.", "prompt": "Write a Python function using a heap to return the k largest elements of a list.", "output": "```python\nimport heapq\n\ndef k_largest(nums, k):\n    if k <= 0:\n        return []\n    heap = nums[:k]\n    heapq.heapify(heap)\n    for x in nums[k:]:\n        if x > heap[0]:\n            heapq.heapreplace(heap, x)\n    return sorted(heap, reverse=True)\n```\n\nUses a min-heap of size k. Time: O(n log k)."},
+    {"system": "You are an expert software engineer. Write clean, correct, efficient code.", "prompt": "Write a Python function that returns all permutations of a given list of distinct integers.", "output": "```python\ndef permutations(nums):\n    result = []\n    def backtrack(path, remaining):\n        if not remaining:\n            result.append(path[:])\n            return\n        for i in range(len(remaining)):\n            backtrack(path + [remaining[i]], remaining[:i] + remaining[i+1:])\n    backtrack([], nums)\n    return result\n```\n\nBacktracking, O(n!) permutations."},
+    {"system": "You are an expert software engineer. Write clean, correct, efficient code.", "prompt": "Write Python code using dynamic programming to compute the length of the longest increasing subsequence in an array.", "output": "```python\ndef lis_length(nums):\n    import bisect\n    tails = []\n    for x in nums:\n        i = bisect.bisect_left(tails, x)\n        if i == len(tails):\n            tails.append(x)\n        else:\n            tails[i] = x\n    return len(tails)\n```\n\nPatience sorting: O(n log n) time, O(n) space."},
+    {"system": "You are an expert software engineer. Write clean, correct, efficient code.", "prompt": "Write a Python function that checks whether a binary tree is balanced (heights differ by at most 1).", "output": "```python\ndef is_balanced(root):\n    def height(node):\n        if not node:\n            return 0\n        left = height(node.left)\n        right = height(node.right)\n        if left == -1 or right == -1 or abs(left - right) > 1:\n            return -1\n        return 1 + max(left, right)\n    return height(root) != -1\n```\n\nDFS returns -1 for unbalanced subtree. O(n) time."},
+    {"system": "You are an expert software engineer. Write clean, correct, efficient code.", "prompt": "Write Python code using a queue (BFS) to find the shortest path length in a grid from (0,0) to (n-1,m-1) avoiding walls.", "output": "```python\nfrom collections import deque\n\ndef shortest_path(grid):\n    n, m = len(grid), len(grid[0])\n    if grid[0][0] == 1 or grid[n-1][m-1] == 1:\n        return -1\n    q = deque([(0, 0, 1)])\n    grid[0][0] = 1\n    while q:\n        r, c, d = q.popleft()\n        if (r, c) == (n-1, m-1):\n            return d\n        for dr, dc in ((1,0),(-1,0),(0,1),(0,-1)):\n            nr, nc = r+dr, c+dc\n            if 0 <= nr < n and 0 <= nc < m and grid[nr][nc] == 0:\n                grid[nr][nc] = 1\n                q.append((nr, nc, d+1))\n    return -1\n```\n\nBFS on grid: O(n*m)."},
+    {"system": "You are an expert software engineer. Write clean, correct, efficient code.", "prompt": "Write Python code using a hash map to find two numbers in a list that sum to a target.", "output": "```python\ndef two_sum(nums, target):\n    seen = {}\n    for i, x in enumerate(nums):\n        complement = target - x\n        if complement in seen:\n            return [seen[complement], i]\n        seen[x] = i\n    return []\n```\n\nSingle pass, O(n) time, O(n) space."},
+    {"system": "You are an expert software engineer. Write clean, correct, efficient code.", "prompt": "Write a Python function that converts an integer to its binary string representation without using bin().", "output": "```python\ndef to_binary(n: int) -> str:\n    if n == 0:\n        return \"0\"\n    bits = []\n    while n:\n        bits.append(str(n & 1))\n        n >>= 1\n    return ''.join(reversed(bits))\n```\n\nRepeatedly takes least significant bit. O(log n) time."},
+    {"system": "You are an expert software engineer. Write clean, correct, efficient code.", "prompt": "Write Python code using Dijkstra's algorithm to find the shortest path in a weighted graph.", "output": "```python\nimport heapq\n\ndef dijkstra(graph, start):\n    dist = {node: float('inf') for node in graph}\n    dist[start] = 0\n    pq = [(0, start)]\n    while pq:\n        d, u = heapq.heappop(pq)\n        if d > dist[u]:\n            continue\n        for v, w in graph[u]:\n            nd = d + w\n            if nd < dist[v]:\n                dist[v] = nd\n                heapq.heappush(pq, (nd, v))\n    return dist\n```\n\nPriority-queue Dijkstra: O((V+E) log V)."},
+    {"system": "You are an expert software engineer. Write clean, correct, efficient code.", "prompt": "Write a Python function to determine if two strings are anagrams.", "output": "```python\nfrom collections import Counter\n\ndef is_anagram(s: str, t: str) -> bool:\n    if len(s) != len(t):\n        return False\n    return Counter(s) == Counter(t)\n```\n\nCounter comparison is O(n). Works for any character set."},
+    {"system": "You are an expert software engineer. Write clean, correct, efficient code.", "prompt": "Write Python code with a DFS to find all paths from a source to a target in an undirected graph.", "output": "```python\ndef all_paths(graph, src, dst):\n    result = []\n    def dfs(node, path):\n        path.append(node)\n        if node == dst:\n            result.append(path[:])\n        else:\n            for nei in graph[node]:\n                if nei not in path:\n                    dfs(nei, path)\n        path.pop()\n    dfs(src, [])\n    return result\n```\n\nBacktracking DFS enumerates all paths."},
+]
+
+def format_example(ex):
+    return f"""<|im_start|>system
+{ex['system']}<|im_end|>
+<|im_start|>user
+{ex['prompt']}<|im_end|>
+<|im_start|>assistant
+{ex['output']}<|im_end|>"""
+
+def main():
+    print("Loading tokenizer...")
+    tokenizer = AutoTokenizer.from_pretrained(
+        MODEL_NAME, trust_remote_code=True, use_fast=True
+    )
+    tokenizer.pad_token = tokenizer.eos_token
+    tokenizer.padding_side = "right"
+
+    print("Loading model with 4-bit quantization...")
+    bnb_config = BitsAndBytesConfig(
+        load_in_4bit=True,
+        bnb_4bit_quant_type="nf4",
+        bnb_4bit_compute_dtype=torch.bfloat16,
+        bnb_4bit_use_double_quant=True,
+    )
+
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL_NAME,
+        quantization_config=bnb_config,
+        device_map="auto",
+        trust_remote_code=True,
+        torch_dtype=torch.bfloat16,
+    )
+
+    model = prepare_model_for_kbit_training(model)
+    model.gradient_checkpointing_enable()
+
+    lora_config = LoraConfig(
+        r=32,
+        lora_alpha=64,
+        target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
+        lora_dropout=0.05,
+        bias="none",
+        task_type=TaskType.CAUSAL_LM,
+    )
+
+    model = get_peft_model(model, lora_config)
+    model.print_trainable_parameters()
+
+    print("Preparing dataset...")
+    formatted_data = [{"text": format_example(ex)} for ex in PROG_DATA]
+    dataset = Dataset.from_list(formatted_data)
+
+    def tokenize_function(examples):
+        result = tokenizer(
+            examples["text"],
+            truncation=True,
+            max_length=1024,
+            padding="max_length",
+            return_tensors="pt",
+        )
+        result["labels"] = result["input_ids"].clone()
+        return result
+
+    tokenized_dataset = dataset.map(
+        tokenize_function, batched=True, remove_columns=["text"]
+    )
+    tokenized_dataset.set_format(
+        type="torch", columns=["input_ids", "attention_mask", "labels"]
+    )
+
+    training_args = TrainingArguments(
+        output_dir=OUTPUT_DIR,
+        num_train_epochs=2,
+        per_device_train_batch_size=2,
+        gradient_accumulation_steps=4,
+        warmup_steps=5,
+        learning_rate=2e-4,
+        fp16=False,
+        bf16=True,
+        logging_steps=5,
+        save_steps=500,
+        save_total_limit=2,
+        optim="paged_adamw_8bit",
+        lr_scheduler_type="cosine",
+        report_to="none",
+        remove_unused_columns=False,
+        dataloader_pin_memory=False,
+        max_grad_norm=0.3,
+    )
+
+    data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False)
+
+    trainer = Trainer(
+        model=model,
+        train_dataset=tokenized_dataset,
+        args=training_args,
+        data_collator=data_collator,
+    )
+
+    print("Starting training...")
+    trainer.train()
+
+    print("Saving model...")
+    trainer.save_model()
+    tokenizer.save_pretrained(OUTPUT_DIR)
+    print(f"Model saved to {OUTPUT_DIR}")
+
+if __name__ == "__main__":
+    main()

scripts/programming_finetune_aggressive.py

@@ -0,0 +1,174 @@
+import os
+os.environ["CUDA_VISIBLE_DEVICES"] = "1"
+os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True"
+
+import torch
+from datasets import load_dataset, Dataset
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    TrainingArguments,
+    Trainer,
+    BitsAndBytesConfig,
+)
+from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training, TaskType
+from dataclasses import dataclass
+from transformers import DataCollatorWithPadding
+
+MODEL_NAME = "Qwen/Qwen2.5-Coder-7B-Instruct"
+OUTPUT_DIR = "/home/ai/qwen-coder-programming-best"
+SYSTEM = "You are an expert software engineer. Write clean, correct, efficient, well-structured code with brief explanations."
+
+EXPERT_EXAMPLES = [
+    {"instruction": "Write a Python function to check if a string is a valid palindrome ignoring case and non-alphanumeric characters.", "input": "", "output": "```python\ndef is_palindrome(s: str) -> bool:\n    cleaned = ''.join(c.lower() for c in s if c.isalnum())\n    return cleaned == cleaned[::-1]\n```\n\nTime: O(n), Space: O(n). Returns True for 'A man, a plan, a canal: Panama'."},
+    {"instruction": "Write a Python function using a binary search to find the index of a target in a sorted list, or -1 if not present.", "input": "", "output": "```python\ndef binary_search(arr, target):\n    low, high = 0, len(arr) - 1\n    while low <= high:\n        mid = (low + high) // 2\n        if arr[mid] == target:\n            return mid\n        elif arr[mid] < target:\n            low = mid + 1\n        else:\n            high = mid - 1\n    return -1\n```\n\nTime: O(log n), Space: O(1)."},
+    {"instruction": "Write a Python class implementing a simple LRU cache with get and put operations in O(1).", "input": "", "output": "```python\nfrom collections import OrderedDict\n\nclass LRUCache:\n    def __init__(self, capacity: int):\n        self.capacity = capacity\n        self.cache = OrderedDict()\n\n    def get(self, key: int) -> int:\n        if key not in self.cache:\n            return -1\n        self.cache.move_to_end(key)\n        return self.cache[key]\n\n    def put(self, key: int, value: int) -> None:\n        if key in self.cache:\n            self.cache.move_to_end(key)\n        self.cache[key] = value\n        if len(self.cache) > self.capacity:\n            self.cache.popitem(last=False)\n```\n\nBoth operations are O(1) using OrderedDict."},
+    {"instruction": "Write Python code using a queue (BFS) to find the shortest path length in a grid from (0,0) to (n-1,m-1) avoiding walls.", "input": "", "output": "```python\nfrom collections import deque\n\ndef shortest_path(grid):\n    n, m = len(grid), len(grid[0])\n    if grid[0][0] == 1 or grid[n-1][m-1] == 1:\n        return -1\n    q = deque([(0, 0, 1)])\n    grid[0][0] = 1\n    while q:\n        r, c, d = q.popleft()\n        if (r, c) == (n-1, m-1):\n            return d\n        for dr, dc in ((1,0),(-1,0),(0,1),(0,-1)):\n            nr, nc = r+dr, c+dc\n            if 0 <= nr < n and 0 <= nc < m and grid[nr][nc] == 0:\n                grid[nr][nc] = 1\n                q.append((nr, nc, d+1))\n    return -1\n```\n\nBFS on grid: O(n*m)."},
+    {"instruction": "Write Python code using Dijkstra's algorithm to find the shortest path in a weighted graph.", "input": "", "output": "```python\nimport heapq\n\ndef dijkstra(graph, start):\n    dist = {node: float('inf') for node in graph}\n    dist[start] = 0\n    pq = [(0, start)]\n    while pq:\n        d, u = heapq.heappop(pq)\n        if d > dist[u]:\n            continue\n        for v, w in graph[u]:\n            nd = d + w\n            if nd < dist[v]:\n                dist[v] = nd\n                heapq.heappush(pq, (nd, v))\n    return dist\n```\n\nPriority-queue Dijkstra: O((E+V) log V)."},
+    {"instruction": "Write a Python function using dynamic programming to compute the length of the longest increasing subsequence in an array.", "input": "", "output": "```python\ndef lis_length(nums):\n    import bisect\n    tails = []\n    for x in nums:\n        i = bisect.bisect_left(tails, x)\n        if i == len(tails):\n            tails.append(x)\n        else:\n            tails[i] = x\n    return len(tails)\n```\n\nPatience sorting: O(n log n) time, O(n) space."},
+]
+
+# ----------------------------------------------------------------
+# Load and filter CodeAlpaca-18k
+ds = load_dataset("iamtarun/python_code_instructions_18k_alpaca", split="train")
+
+def filter_quality(ex):
+    out = ex["output"] or ""
+    ins = ex["instruction"] or ""
+    if not ins.strip() or len(ins) > 2000:
+        return False
+    if len(out) < 10 or len(out) > 2000:
+        return False
+    if "def " not in out and "import " not in out and "class " not in out and "{" not in out and "function" not in out.lower():
+        return False
+    return True
+
+ds = ds.filter(filter_quality, num_proc=4)
+ds = ds.shuffle(seed=42)
+N = 6000
+ds = ds.select(range(min(N, len(ds))))
+
+expert_ds = Dataset.from_list(EXPERT_EXAMPLES)
+
+def normalize(ex):
+    return {"instruction": ex["instruction"], "input_text": str(ex.get("input") or ""), "output": ex["output"]}
+
+ds = ds.map(normalize, remove_columns=ds.column_names)
+expert_ds = expert_ds.map(lambda e: {"instruction": e["instruction"], "input_text": str(e.get("input") or ""), "output": e["output"]})
+ds = Dataset.from_list(expert_ds.to_list() + ds.to_list())
+print(f"Final train examples: {len(ds)}")
+
+# ----------------------------------------------------------------
+def main():
+    print("Loading tokenizer...")
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True, use_fast=True)
+    tokenizer.pad_token = tokenizer.eos_token
+    tokenizer.padding_side = "right"
+
+    bnb_config = BitsAndBytesConfig(
+        load_in_4bit=True,
+        bnb_4bit_quant_type="nf4",
+        bnb_4bit_compute_dtype=torch.bfloat16,
+        bnb_4bit_use_double_quant=True,
+    )
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL_NAME, quantization_config=bnb_config, device_map="auto",
+        trust_remote_code=True, torch_dtype=torch.bfloat16,
+    )
+    model = prepare_model_for_kbit_training(model)
+    model.gradient_checkpointing_enable()
+    model.enable_input_require_grads()
+
+    lora_config = LoraConfig(
+        r=64,
+        lora_alpha=128,
+        target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
+        lora_dropout=0.05,
+        bias="none",
+        task_type=TaskType.CAUSAL_LM,
+        use_rslora=True,
+    )
+    model = get_peft_model(model, lora_config)
+    model.print_trainable_parameters()
+
+    def format_chat(ex):
+        user_content = ex["instruction"] + (f"\n\nInput:\n{ex['input_text']}" if ex["input_text"] else "")
+        prefix = f"<|im_start|>system\n{SYSTEM}<|im_end|>\n<|im_start|>user\n{user_content}<|im_end|>\n"
+        suffix = f"<|im_start|>assistant\n{ex['output']}<|im_end|>"
+        return {"prefix": prefix, "suffix": suffix}
+
+    def tokenize_with_masks(ex, max_length=2048):
+        p = tokenizer(ex["prefix"], add_special_tokens=False)
+        s = tokenizer(ex["suffix"], add_special_tokens=False)
+        input_ids = (p["input_ids"] + s["input_ids"])[:max_length]
+        labels = ([-100] * len(p["input_ids"]) + s["input_ids"])[:max_length]
+        attention_mask = [1] * len(input_ids)
+        return {"input_ids": input_ids, "labels": labels, "attention_mask": attention_mask}
+
+    ds_map = ds.map(format_chat, remove_columns=ds.column_names)
+    ds_map = ds_map.map(
+        lambda e: tokenize_with_masks(e),
+        remove_columns=ds_map.column_names,
+        batched=False,
+    )
+    print("Sample input ids len:", len(ds_map[0]["input_ids"]))
+
+    class CompletionOnlyDataCollator:
+        def __init__(self, tokenizer):
+            self.tokenizer = tokenizer
+        def __call__(self, features):
+            pad_id = self.tokenizer.pad_token_id
+            max_len = max(len(f["input_ids"]) for f in features)
+            input_ids, attention_mask, labels = [], [], []
+            for f in features:
+                ids, mask, lab = f["input_ids"], f["attention_mask"], f["labels"]
+                pad = max_len - len(ids)
+                input_ids.append(ids + [pad_id] * pad)
+                attention_mask.append(mask + [0] * pad)
+                labels.append(lab + [-100] * pad)
+            return {
+                "input_ids": torch.tensor(input_ids, dtype=torch.long),
+                "attention_mask": torch.tensor(attention_mask, dtype=torch.long),
+                "labels": torch.tensor(labels, dtype=torch.long),
+            }
+
+    training_args = TrainingArguments(
+        output_dir=OUTPUT_DIR,
+        num_train_epochs=3,
+        per_device_train_batch_size=8,
+        gradient_accumulation_steps=4,
+        warmup_steps=80,
+        learning_rate=2e-4,
+        lr_scheduler_type="cosine",
+        weight_decay=0.0,
+        fp16=False,
+        bf16=True,
+        max_grad_norm=1.0,
+        logging_steps=20,
+        save_steps=250,
+        save_total_limit=2,
+        optim="adamw_8bit",
+        report_to="none",
+        remove_unused_columns=False,
+        dataloader_pin_memory=False,
+        gradient_checkpointing_kwargs={"use_reentrant": False},
+    )
+
+    collator = CompletionOnlyDataCollator(tokenizer=tokenizer)
+
+    trainer = Trainer(
+        model=model,
+        train_dataset=ds_map,
+        args=training_args,
+        data_collator=collator,
+    )
+
+    print("Starting aggressive training...")
+    trainer.train()
+
+    trainer.save_model()
+    tokenizer.save_pretrained(OUTPUT_DIR)
+    print(f"Model saved to {OUTPUT_DIR}")
+
+if __name__ == "__main__":
+    main()

scripts/security_finetune.py

@@ -0,0 +1,168 @@
+import os
+import os
+os.environ["CUDA_VISIBLE_DEVICES"] = "1"
+
+import json
+import torch
+from datasets import Dataset
+from transformers import (
+    AutoModelForCausalLM,
+    AutoTokenizer,
+    TrainingArguments,
+    Trainer,
+    DataCollatorForLanguageModeling,
+    BitsAndBytesConfig
+)
+from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training, TaskType
+
+MODEL_NAME = "codellama/CodeLlama-7b-Instruct-hf"
+OUTPUT_DIR = "/home/ai/codellama-security-finetuned"
+
+SECURITY_DATA = [
+    {"instruction": "Identify the vulnerability in this code", "input": "```python\nimport sqlite3\nconn = sqlite3.connect('users.db')\ncursor = conn.cursor()\nusername = input('Enter username: ')\nquery = f\"SELECT * FROM users WHERE username = '{username}'\"\ncursor.execute(query)\n```", "output": "SQL Injection vulnerability. The query uses string interpolation directly with user input. Fix: Use parameterized queries: `cursor.execute(\"SELECT * FROM users WHERE username = ?\", (username,))`"},
+    
+    {"instruction": "Find the security flaw", "input": "```python\nimport subprocess\nfilename = input('Enter filename: ')\nsubprocess.run(f'cat {filename}', shell=True)\n```", "output": "Command Injection via shell=True and unsanitized user input. Fix: Use `subprocess.run(['cat', filename], shell=False)` with input validation."},
+    
+    {"instruction": "What vulnerability exists here?", "input": "```python\nimport pickle\ndata = pickle.loads(request.data)\n```", "output": "Insecure Deserialization. Pickle can execute arbitrary code during deserialization. Fix: Use JSON or safe serialization formats, validate input."},
+    
+    {"instruction": "Identify the XSS vulnerability", "input": "```javascript\napp.get('/search', (req, res) => {\n  res.send(`<h1>Results for: ${req.query.q}</h1>`);\n});\n```", "output": "Reflected XSS. User input directly rendered in HTML without escaping. Fix: Use template engines with auto-escaping or sanitize input with DOMPurify."},
+    
+    {"instruction": "Find the authentication bypass", "input": "```python\n@app.route('/admin')\ndef admin():\n    if request.headers.get('X-User-Role') == 'admin':\n        return 'Admin panel'\n    return 'Forbidden', 403\n```", "output": "Client-side authorization check. Header can be spoofed. Fix: Use server-side session validation with proper authentication tokens."},
+    
+    {"instruction": "What's wrong with this crypto implementation?", "input": "```python\nfrom Crypto.Cipher import AES\nkey = b'mysecretkey12345'\ncipher = AES.new(key, AES.MODE_ECB)\nciphertext = cipher.encrypt(pad(data, 16))\n```", "output": "AES-ECB mode is insecure (deterministic, reveals patterns). Hardcoded key. Fix: Use AES-GCM with random IV, derive key via PBKDF2/Argon2."},
+    
+    {"instruction": "Identify the path traversal", "input": "```python\n@app.route('/download')\ndef download():\n    filename = request.args.get('file')\n    return send_file(f'/var/www/files/{filename}')\n```", "output": "Path Traversal. No validation on filename allows `../../etc/passwd`. Fix: Use `secure_filename`, validate against allowlist, use `os.path.basename`."},
+    
+    {"instruction": "Find the SSRF vulnerability", "input": "```python\nimport requests\nurl = request.args.get('url')\nresponse = requests.get(url)\nreturn response.text\n```", "output": "Server-Side Request Forgery (SSRF). User controls URL parameter, can access internal services. Fix: Validate URL against allowlist, block private IPs, use allowlist of domains."},
+    
+    {"instruction": "What's the race condition here?", "input": "```python\ndef transfer(from_acc, to_acc, amount):\n    if get_balance(from_acc) >= amount:\n        debit(from_acc, amount)\n        credit(to_acc, amount)\n```", "output": "TOCTOU Race Condition. Balance check and transfer aren't atomic. Fix: Use database transactions with SELECT FOR UPDATE or atomic operations."},
+    
+    {"instruction": "Identify the JWT vulnerability", "input": "```python\nimport jwt\ntoken = request.headers.get('Authorization')\npayload = jwt.decode(token, 'secret', algorithms=['HS256'])\n```", "output": "Hardcoded secret, no algorithm validation (allows 'none' alg), no expiration check. Fix: Use strong secret from env, specify algorithms=['HS256'], verify exp claim."},
+    
+    {"instruction": "Find the XXE vulnerability", "input": "```python\nimport xml.etree.ElementTree as ET\ndef parse_xml(xml_data):\n    return ET.fromstring(xml_data)\n```", "output": "XML External Entity (XXE) injection. Parser processes external entities. Fix: Disable DTD processing: `ET.XMLParser(resolve_entities=False)` or use defusedxml."},
+    
+    {"instruction": "What's the issue with this CORS config?", "input": "```python\napp.add_middleware(CORSMiddleware,\n    allow_origins=['*'],\n    allow_credentials=True,\n    allow_methods=['*'],\n    allow_headers=['*']\n)\n```", "output": "Wildcard origin with credentials enabled - violates CORS spec, allows credential theft. Fix: Specify exact origins, don't use '*' with credentials."},
+    
+    {"instruction": "Identify the insecure direct object reference", "input": "```python\n@app.route('/api/user/<int:user_id>/profile')\ndef get_profile(user_id):\n    return jsonify(db.query(User).filter_by(id=user_id).first())\n```", "output": "IDOR - No authorization check. Users can access any profile by changing user_id. Fix: Verify current user owns the resource or has permission."},
+    
+    {"instruction": "Find the weak randomness", "input": "```python\nimport random\nsession_token = ''.join(random.choices('abcdefghijklmnopqrstuvwxyz0123456789', k=32))\n```", "output": "Using random (Mersenne Twister) for cryptographic purposes - predictable. Fix: Use `secrets.token_urlsafe(32)` or `os.urandom()` for crypto-safe randomness."},
+    
+    {"instruction": "What's the container escape risk?", "input": "```dockerfile\nFROM ubuntu:latest\nRUN apt-get update && apt-get install -y docker.io\nVOLUME /var/run/docker.sock\n```", "output": "Mounting docker.sock gives container root access to host. Fix: Don't mount docker.sock; use socket proxies like docker-socket-proxy with limited permissions."},
+    
+    {"instruction": "Identify the supply chain attack vector", "input": "```json\n{\n  \"dependencies\": {\n    \"left-pad\": \"^1.0.0\",\n    \"event-stream\": \"^3.3.4\"\n  }\n}\n```", "output": "Unpinned dependencies allow malicious updates. event-stream was compromised. Fix: Pin exact versions, use lockfiles, enable Dependabot, verify package integrity with npm audit/signatures."},
+    
+    {"instruction": "Find the timing attack vulnerability", "input": "```python\ndef verify_token(token, expected):\n    return token == expected\n```", "output": "String comparison short-circuits - timing attack reveals token character by character. Fix: Use `hmac.compare_digest(token, expected)` for constant-time comparison."},
+    
+    {"instruction": "What's the log injection issue?", "input": "```python\nimport logging\nlogging.info(f'User {username} logged in from {ip}')\n```", "output": "Log Injection - username/ip can contain newlines to forge log entries. Fix: Sanitize input, use structured logging (JSON), escape newlines."},
+    
+    {"instruction": "Identify the broken access control", "input": "```python\n@app.route('/api/admin/delete-user/<int:id>')\ndef delete_user(id):\n    User.query.filter_by(id=id).delete()\n    return 'OK'\n```", "output": "Missing authorization - any authenticated user can delete users. Fix: Add @require_admin decorator, check user permissions before action."},
+    
+    {"instruction": "Find the prototype pollution", "input": "```javascript\nfunction merge(target, source) {\n  for (let key in source) {\n    target[key] = source[key];\n  }\n}\nmerge({}, JSON.parse(userInput));\n```", "output": "Prototype Pollution - `__proto__` or `constructor.prototype` in input pollutes Object.prototype. Fix: Validate keys, use `Object.create(null)`, freeze prototype, use lodash.mergeWith."},
+    
+    {"instruction": "What's the deserialization RCE?", "input": "```java\nObjectInputStream ois = new ObjectInputStream(new FileInputStream(\"data.ser\"));\nObject obj = ois.readObject();\n```", "output": "Java Deserialization RCE - gadget chains (CommonsCollections, etc.) execute code. Fix: Avoid native serialization, use JSON, implement ObjectInputFilter, use SerialKiller/NotSoSerial."}
+]
+
+def format_example(example):
+    return f"""<|begin_of_text|><|start_header_id|>system<|end_header_id|>
+You are a cybersecurity expert specializing in vulnerability assessment, penetration testing, and secure code review. Identify security flaws, explain the impact, and provide remediation.
+<|eot_id|><|start_header_id|>user<|end_header_id|>
+{example['instruction']}
+
+{example['input']}
+<|eot_id|><|start_header_id|>assistant<|end_header_id|>
+{example['output']}
+<|eot_id|>"""
+
+def main():
+    print("Loading tokenizer...")
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, trust_remote_code=True)
+    tokenizer.pad_token = tokenizer.eos_token
+    tokenizer.padding_side = "right"
+    
+    print("Loading model with 4-bit quantization...")
+    bnb_config = BitsAndBytesConfig(
+        load_in_4bit=True,
+        bnb_4bit_quant_type="nf4",
+        bnb_4bit_compute_dtype=torch.bfloat16,
+        bnb_4bit_use_double_quant=True,
+    )
+    
+    model = AutoModelForCausalLM.from_pretrained(
+        MODEL_NAME,
+        quantization_config=bnb_config,
+        device_map="auto",
+        trust_remote_code=True,
+        torch_dtype=torch.bfloat16,
+    )
+    
+    model = prepare_model_for_kbit_training(model)
+    
+    lora_config = LoraConfig(
+        r=64,
+        lora_alpha=128,
+        target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
+        lora_dropout=0.05,
+        bias="none",
+        task_type=TaskType.CAUSAL_LM,
+    )
+    
+    model = get_peft_model(model, lora_config)
+    model.print_trainable_parameters()
+    
+    print("Preparing dataset...")
+    formatted_data = [{"text": format_example(ex)} for ex in SECURITY_DATA]
+    dataset = Dataset.from_list(formatted_data)
+    
+    def tokenize_function(examples):
+        result = tokenizer(
+            examples["text"],
+            truncation=True,
+            max_length=1024,
+            padding="max_length",
+            return_tensors="pt"
+        )
+        result["labels"] = result["input_ids"].clone()
+        return result
+    
+    tokenized_dataset = dataset.map(tokenize_function, batched=True, remove_columns=["text"])
+    tokenized_dataset.set_format(type="torch", columns=["input_ids", "attention_mask", "labels"])
+    
+    training_args = TrainingArguments(
+        output_dir=OUTPUT_DIR,
+        num_train_epochs=3,
+        per_device_train_batch_size=1,
+        gradient_accumulation_steps=8,
+        warmup_steps=10,
+        learning_rate=2e-4,
+        fp16=False,
+        bf16=True,
+        logging_steps=5,
+        save_steps=50,
+        save_total_limit=2,
+        optim="paged_adamw_8bit",
+        lr_scheduler_type="cosine",
+        report_to="none",
+        remove_unused_columns=False,
+        dataloader_pin_memory=False,
+        max_grad_norm=0.3,
+    )
+    
+    data_collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False)
+    
+    trainer = Trainer(
+        model=model,
+        train_dataset=tokenized_dataset,
+        args=training_args,
+        data_collator=data_collator,
+    )
+    
+    print("Starting training...")
+    trainer.train()
+    
+    print("Saving model...")
+    trainer.save_model()
+    tokenizer.save_pretrained(OUTPUT_DIR)
+    print(f"Model saved to {OUTPUT_DIR}")
+
+if __name__ == "__main__":
+    main()

scripts/test_programming_model.py

@@ -0,0 +1,53 @@
+import os
+os.environ["CUDA_VISIBLE_DEVICES"] = "1"
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
+from peft import PeftModel
+
+BASE_MODEL = "Qwen/Qwen2.5-Coder-7B-Instruct"
+ADAPTER_PATH = "/home/ai/qwen-coder-programming-finetuned"
+
+def load_model():
+    bnb_config = BitsAndBytesConfig(
+        load_in_4bit=True,
+        bnb_4bit_quant_type="nf4",
+        bnb_4bit_compute_dtype=torch.bfloat16,
+        bnb_4bit_use_double_quant=True,
+    )
+    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, ADAPTER_PATH)
+    tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL, trust_remote_code=True, use_fast=True)
+    tokenizer.pad_token = tokenizer.eos_token
+    return model, tokenizer
+
+def generate(model, tokenizer, prompt):
+    messages = [{"role": "user", "content": prompt}]
+    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
+    inputs = tokenizer(text, return_tensors="pt").to(model.device)
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs, max_new_tokens=512, temperature=0.3, top_p=0.9,
+            do_sample=True, repetition_penalty=1.1, pad_token_id=tokenizer.pad_token_id,
+        )
+    return tokenizer.decode(outputs[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True)
+
+def main():
+    model, tokenizer = load_model()
+    tests = [
+        "Write a Python function to merge two sorted lists into one sorted list.",
+        "Write a Python class implementing a simple LRU cache with get and put operations in O(1).",
+        "Write a Python function using dynamic programming to compute the length of the longest increasing subsequence in an array.",
+        "Write Python code using Dijkstra's algorithm to find the shortest path in a weighted graph.",
+    ]
+    for t in tests:
+        print("=" * 60)
+        print("PROMPT:", t)
+        print("-" * 60)
+        print(generate(model, tokenizer, t))
+        print()
+
+if __name__ == "__main__":
+    main()

scripts/test_security_model.py

@@ -0,0 +1,106 @@
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
+from peft import PeftModel
+
+BASE_MODEL = "codellama/CodeLlama-7b-Instruct-hf"
+ADAPTER_PATH = "/home/ai/codellama-security-finetuned"
+
+def load_model():
+    print("Loading base model...")
+    bnb_config = BitsAndBytesConfig(
+        load_in_4bit=True,
+        bnb_4bit_quant_type="nf4",
+        bnb_4bit_compute_dtype=torch.bfloat16,
+        bnb_4bit_use_double_quant=True,
+    )
+    
+    model = AutoModelForCausalLM.from_pretrained(
+        BASE_MODEL,
+        quantization_config=bnb_config,
+        device_map="auto",
+        trust_remote_code=True,
+        torch_dtype=torch.bfloat16,
+    )
+    
+    print("Loading LoRA adapter...")
+    model = PeftModel.from_pretrained(model, ADAPTER_PATH)
+    model = model.merge_and_unload()
+    
+    tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL, trust_remote_code=True)
+    tokenizer.pad_token = tokenizer.eos_token
+    
+    return model, tokenizer
+
+def analyze_code(model, tokenizer, code, instruction="Identify all security vulnerabilities in this code"):
+    prompt = f"""<|begin_of_text|><|start_header_id|>system<|end_header_id|>
+You are a cybersecurity expert specializing in vulnerability assessment, penetration testing, and secure code review. Identify security flaws, explain the impact, and provide remediation.
+<|eot_id|><|start_header_id|>user<|end_header_id|>
+{instruction}
+
+```python
+{code}
+```
+<|eot_id|><|start_header_id|>assistant<|end_header_id|>"""
+    
+    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
+    
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_new_tokens=1024,
+            temperature=0.3,
+            top_p=0.9,
+            do_sample=True,
+            repetition_penalty=1.1,
+            pad_token_id=tokenizer.eos_token_id,
+        )
+    
+    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    return response.split("<|start_header_id|>assistant<|end_header_id|>")[-1].strip()
+
+def main():
+    model, tokenizer = load_model()
+    
+    test_cases = [
+        ("SQL Injection", """
+import sqlite3
+def get_user(username):
+    conn = sqlite3.connect('app.db')
+    cursor = conn.cursor()
+    query = f"SELECT * FROM users WHERE name = '{username}'"
+    return cursor.execute(query).fetchall()
+"""),
+        ("Command Injection", """
+import subprocess
+def ping_host(host):
+    result = subprocess.run(f"ping -c 4 {host}", shell=True, capture_output=True)
+    return result.stdout
+"""),
+        ("Path Traversal", """
+from flask import request, send_file
+@app.route('/download')
+def download():
+    filename = request.args.get('file')
+    return send_file(f'/var/www/uploads/{filename}')
+"""),
+        ("Insecure Deserialization", """
+import pickle
+def load_session(data):
+    return pickle.loads(data)
+"""),
+        ("JWT Issues", """
+import jwt
+def verify_token(token):
+    return jwt.decode(token, 'secret123', algorithms=['HS256'])
+"""),
+    ]
+    
+    for name, code in test_cases:
+        print(f"\n{'='*60}")
+        print(f"TEST: {name}")
+        print(f"{'='*60}")
+        result = analyze_code(model, tokenizer, code)
+        print(result)
+
+if __name__ == "__main__":
+    main()