Update README.md

README.md

@@ -1,115 +1,86 @@
-# Qwen Coder Lab
+---
+base_model: Qwen/Qwen2.5-Coder-14B-Instruct
+license: apache-2.0
+language:
+- en
+tags:
+- code
+- coding-assistant
+- lora
+- fine-tuned
+- gguf
+- ollama
+pipeline_tag: text-generation
+---
 
-Starter lab for building a specialized coding assistant on top of:
+# Alpha-Coder-14B
 
-`Qwen/Qwen3-Coder-30B-A3B-Instruct`
+Alpha-Coder-14B is a fine-tuned version of [Qwen2.5-Coder-14B-Instruct](https://huggingface.co/Qwen/Qwen2.5-Coder-14B-Instruct), adapted via LoRA to produce typed, tested Python code. This repo contains both the fused fp16 weights and a Q4_K_M GGUF quant for local inference (e.g. with Ollama or llama.cpp).
 
-This project is set up for three phases:
+## Base model attribution
 
-1. Run the base model locally or on a GPU machine.
-2. Prepare high-quality coding instruction data.
-3. Fine-tune with QLoRA, then quantize/deploy.
+This model is a derivative of **Qwen/Qwen2.5-Coder-14B-Instruct**, released by the Qwen team under the **Apache 2.0 license**. Alpha-Coder-14B is redistributed under the same license, as permitted by Apache 2.0 for derivative/renamed works, with attribution to the original model and authors.
 
-## Hardware Target
+- Base model: [Qwen/Qwen2.5-Coder-14B-Instruct](https://huggingface.co/Qwen/Qwen2.5-Coder-14B-Instruct)
+- License: Apache 2.0
 
-For the 30B-A3B model, practical setups are:
+## Training details
 
-- Inference: 24 GB+ VRAM with 4-bit quantization, or a larger unified-memory machine.
-- QLoRA fine-tuning: 24-48 GB+ VRAM depending on sequence length, batch size, and optimizer.
-- CPU-only: possible only with GGUF/llama.cpp style inference, but slow.
+- **Method:** LoRA fine-tuning
+- **Hardware:** Apple Silicon M5, 24GB unified memory
+- **Framework:** MLX (4-bit base model during training)
+- **LoRA config:** rank = 64, alpha = 128, learning rate = 2e-6
+- **Steps:** 6,160
+- **Validation loss:** 0.383 → 0.252
+- **Post-training:** LoRA adapter fused into the base model, dequantized to fp16 HF safetensors, then converted and quantized to GGUF (Q4_K_M, 8.4GB) via llama.cpp
 
-If your current machine cannot run the model, use the same project on a rented GPU instance.
+## Benchmarks
 
-## MacBook M-Series Path
+| Benchmark | Base (Qwen2.5-Coder-14B-Instruct) | Alpha-Coder-14B |
+|---|---|---|
+| MMLU | 72% | 77% |
+| GSM8K | ~93% (no regression) | 93% |
 
-For a MacBook with 24 GB unified memory, 1 TB SSD, and a 10-core GPU:
+No measurable forgetting was observed on GSM8K after fine-tuning, while MMLU improved by 5 points.
 
-- Run the 30B model through a GGUF runtime such as Ollama, llama.cpp, or LM Studio.
-- Prefer Q3 or Q4 quantization for local inference. Higher precision will likely exceed comfortable memory limits.
-- Keep context length modest at first, such as 4K-16K tokens. Long context can consume a lot of memory.
-- Do not plan to QLoRA fine-tune the 30B model locally. Use a rented NVIDIA GPU for that phase.
-- For local fine-tuning experiments, use a smaller model first, such as a 7B coder model.
+## Files in this repo
 
-Recommended local workflow:
+| File | Description |
+|---|---|
+| `*.safetensors` | Fused fp16 weights (LoRA merged into base), full precision |
+| `tokenizer*` / `*.json` | Tokenizer and config files |
+| `alpha-14b-Q4_K_M.gguf` | Q4_K_M quantized GGUF, ~8.4GB, for llama.cpp / Ollama |
 
-1. Use the Mac to test prompts, collect examples, validate datasets, and run quantized inference.
-2. Use a cloud GPU to fine-tune Qwen3-Coder-30B-A3B-Instruct with QLoRA.
-3. Bring the resulting adapter or merged/quantized model back to the Mac for local inference.
+## Usage with Ollama
 
-Start here: `docs/mac-local-run.md`.
-
-Training and usage roadmap: `docs/train-and-use-roadmap.md`.
-
-Specialist dataset strategy: `docs/dataset-strategy.md`.
-
-Baseline findings: `docs/baseline-findings.md`.
-
-Light deployment strategy: `docs/light-deployment-strategy.md`.
-
-Runtime system prompt: `prompts/product_engineer_system.md`.
-
-Complex benchmark findings: `docs/complex-benchmark-findings.md`.
-
-Current performance report: `docs/current-performance-report.md`.
-
-## Install
-
-```bash
-cd qwen-coder-lab
-python3 -m venv .venv
-source .venv/bin/activate
-pip install -r requirements.txt
-```
-
-If macOS reports missing Command Line Tools when running `python3`, install them with `xcode-select --install`, or use a `uv` Python environment instead.
-
-## Run Chat Inference
+1. Download `alpha-14b-Q4_K_M.gguf` from this repo.
+2. Create a `Modelfile` in the same directory (use your actual system prompt from your local Modelfile).
+3. Build and run:
 
 ```bash
-python scripts/run_chat.py \
-  --model Qwen/Qwen3-Coder-30B-A3B-Instruct \
-  --load-in-4bit
-```
-
-Then type coding requests interactively.
-
-## Dataset Format
-
-Training examples use JSONL:
-
-```json
-{"instruction":"Fix this Python bug.","input":"def add(a,b): return a-b","output":"def add(a, b):\n    return a + b"}
+ollama create alpha-coder -f Modelfile
+ollama run alpha-coder
 ```
 
-Validate examples:
+## Usage with llama.cpp
 
 ```bash
-python scripts/prepare_dataset.py \
-  --input data/examples.jsonl \
-  --output data/prepared.jsonl
+./llama-cli -m alpha-14b-Q4_K_M.gguf -p "Write a Python function that ..."
 ```
 
-## QLoRA Fine-Tuning
+## Usage with transformers (fp16 safetensors)
 
-Start with the config in `configs/qwen3_coder_30b_lora.yaml`.
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
 
-```bash
-python scripts/train_lora.py \
-  --config configs/qwen3_coder_30b_lora.yaml
+model = AutoModelForCausalLM.from_pretrained("Jay2003Bhatt/alpha-coder-14b", torch_dtype="auto", device_map="auto")
+tokenizer = AutoTokenizer.from_pretrained("Jay2003Bhatt/alpha-coder-14b")
 ```
 
-The default config is intentionally conservative. Increase sequence length and batch size only after a small training run succeeds.
-
-## What To Fine-Tune On
+## Intended use
 
-Best data for a coding assistant:
+Alpha-Coder-14B is intended as a coding assistant producing typed, tested Python code. As with any fine-tuned model, evaluate outputs before relying on them in production, particularly for correctness and security-sensitive code.
 
-- issue -> patch examples
-- failing test -> fix examples
-- compiler/type error -> corrected code
-- code review comment -> improved diff
-- refactoring requests
-- multi-language explanations plus executable solutions
-- repo-specific style examples
+## License
 
-Avoid low-quality scraped code. For coding models, clean task/answer pairs beat giant noisy dumps.
+Apache 2.0, inherited from the base model. See the [Qwen2.5-Coder-14B-Instruct license](https://huggingface.co/Qwen/Qwen2.5-Coder-14B-Instruct/blob/main/LICENSE) for details.