MODIFY README

README.md

@@ -1,200 +1,68 @@
 ---
-license: mit
-base_model: Qwen/Qwen2.5-Coder-0.5B-Instruct
+license: apache-2.0
+base_model: "Qwen/Qwen2.5-Coder-0.5B-Instruct"
 library_name: peft
 pipeline_tag: text-generation
 tags:
   - code
   - lora
+  - coding-assistant
   - structured-output
 ---
 
-# Advanced Fine-Tune Coding Model (Local + Hugging Face)
-
-This project fine-tunes `Qwen/Qwen2.5-Coder-0.5B-Instruct` using LoRA for:
-- code fixing
-- debugging
-- explanation
-- confidence and relevancy-aware outputs
-
-## Files
-
-- `generate_dataset.py`: creates training dataset (5k-10k)
-- `finetune_coding_llm_colab.py`: local training script (LoRA) + optional upload
-- `infer_local.py`: test local trained model with structured JSON output
-- `infer_cloud.py`: run Hugging Face API inference and force the same structured JSON output
-- `handler.py`: custom Hugging Face Inference Endpoint handler that returns the same JSON contract from the hosted endpoint
-- `evaluate_model.py`: run multi-prompt quality checks and report accuracy
-- `upload_to_hf.py`: upload local model folder to HF
-- `run_pipeline.py`: one command for generate + train (+ optional upload)
-- `requirements.txt`: Python dependencies
-- `training_config.json`: default values automatically used by `run_pipeline.py`
-
-## Local Setup (No Colab)
-
-Install dependencies:
-
-```bash
-pip install -r requirements.txt
-```
-
-Generate dataset (example: 8000 samples):
-
-```bash
-python generate_dataset.py --size 8000 --out train.json
-```
-
-Train locally:
-
-```bash
-python finetune_coding_llm_colab.py --dataset-size 8000
-```
-
-Enable 4-bit quantized loading (GPU):
-
-```bash
-python finetune_coding_llm_colab.py --dataset-size 8000 --use-4bit
-```
-
-Fast CPU smoke run:
-
-```bash
-python finetune_coding_llm_colab.py --dataset-size 5000 --max-train-samples 200 --epochs 0.1
-```
-
-Single command pipeline (no upload):
-
-```bash
-python run_pipeline.py --dataset-size 8000 --skip-upload
-```
-
-If `training_config.json` exists, `run_pipeline.py` reads it automatically for defaults.
-
-Use existing dataset without regenerating:
-
-```bash
-python run_pipeline.py --dataset-size 8000 --train-file train.json --skip-generate --skip-upload
-```
-
-Tunable training knobs:
-
-```bash
-python run_pipeline.py --dataset-size 8000 --epochs 3 --batch-size 2 --learning-rate 1e-4 --max-length 512 --max-train-samples 0 --use-4bit --skip-upload
-```
-
-## Configure 5k-10k samples
-
-```python
---dataset-size 5000
---dataset-size 8000
---dataset-size 10000
-```
-
-Recommended values:
-- 5000 for fast iteration
-- 8000 as balanced
-- 10000 for stronger adaptation (slower)
-
-## Hugging Face Deployment
-
-Upload is optional and can be done after training:
-
-```bash
-python upload_to_hf.py --model-dir model --repo-id your-username/your-model-name
-```
-
-### Update Existing HF Model Repo
-
-To update your already-created Hugging Face model with this new JSON-output behavior:
-
-1. Retrain locally with latest code:
-```bash
-python run_pipeline.py --dataset-size 8000 --skip-upload
-```
-
-2. Login to Hugging Face:
-```bash
-huggingface-cli login
-```
-
-3. Upload to the same repo ID (this updates existing files):
-```bash
-python upload_to_hf.py --model-dir model --repo-id your-username/your-existing-model-name
-```
-
-Optional safer rollout using a new revision/branch:
-```bash
-python -c "from huggingface_hub import upload_folder; upload_folder(folder_path='model', repo_id='your-username/your-existing-model-name', repo_type='model', revision='v2-json-output')"
-```
-
-You can also trigger upload from trainer:
-
-```bash
-python finetune_coding_llm_colab.py --skip-dataset-gen --skip-train --upload --hf-repo your-username/your-model-name
-```
-
-## Quick Inference Test (Structured JSON)
-
-After local training, inference returns JSON with:
-- `code`
-- `explanation`
-- `confidence`
-- `important_tokens`
-- `relevancy_score`
-- `hallucination`
-- `hallucination_check_reason`
-- `latency_ms`
-
-```python
-python infer_local.py --model-path model --prompt "Fix this code: def add(a,b) return a+b"
-```
+# ConicAI Coding LLM
 
-Local inference uses cached model files by default to avoid slow network checks. If the base model is not already cached on a new machine, run once with:
+## Model Details
 
-```bash
-python infer_local.py --model-path model --prompt "Fix this code: def add(a,b) return a+b" --allow-downloads
-```
+* **Model Name:** ConicAI Coding LLM
+* **Developer:** GIRISH KUMAR DEWANGAN
+* **Base Model:** Qwen/Qwen2.5-Coder-0.5B-Instruct
+* **Architecture:** Transformer (Causal LM)
+* **Fine-tuning Method:** LoRA (PEFT)
+* **Task Domain:** Code Generation, Debugging, Explanation
+* **Primary Language:** Python
 
-Run the same structured-output wrapper through the Hugging Face API:
+---
 
-```bash
-set HF_TOKEN=your_huggingface_token
-python infer_cloud.py --repo-id your-username/your-model-name --prompt "Fix this code: def add(a,b) return a+b"
-```
+## Model Description
 
-If `infer_cloud.py` falls back to local inference on a new machine that has not cached the base model yet, add `--allow-downloads`.
+ConicAI Coding LLM is a parameter-efficient fine-tuned model optimized for structured coding tasks.
+It enhances the base model’s reasoning ability by introducing instruction-conditioned outputs and structured response generation.
 
-PowerShell:
+The model focuses on three key aspects:
 
-```powershell
-$env:HF_TOKEN="your_huggingface_token"
-python infer_cloud.py --repo-id your-username/your-model-name --prompt "Fix this code: def add(a,b) return a+b"
-```
+* **Accuracy** → Correct code generation
+* **Interpretability** → Explanation + confidence
+* **Efficiency** → Lightweight fine-tuning
 
-If you already ran `hf auth login` or `huggingface-cli login`, you can omit `HF_TOKEN`; the saved token will be used automatically.
+---
 
-For true cloud execution, deploy the model as a Hugging Face Dedicated Inference Endpoint and pass the endpoint URL:
+## Core Design Philosophy
 
-```powershell
-$env:HF_TOKEN="your_huggingface_token"
-python infer_cloud.py --endpoint-url "https://your-endpoint-url.endpoints.huggingface.cloud" --prompt "Fix this code: def add(a,b) return a+b" --no-local-fallback
-```
+1. **Instruction Conditioning**
 
-You can also use environment variables:
+   ```
+   Instruction → Input → Output
+   ```
 
-```powershell
-$env:HF_TOKEN="your_huggingface_token"
-$env:HF_ENDPOINT_URL="https://your-endpoint-url.endpoints.huggingface.cloud"
-python infer_cloud.py --prompt "Fix this code: def add(a,b) return a+b" --no-local-fallback
-```
+2. **Structured Output Learning**
+
+3. **Post-Generation Validation Awareness**
+
+---
 
-`infer_cloud.py` applies the same JSON parsing, Python syntax check, relevancy score, hallucination flag, and auto-repair fallback as `infer_local.py`. If Hugging Face cannot serve your custom model repo through an inference provider, the script automatically falls back to the local `model/` folder so the command still returns the local-style JSON. Use `--no-local-fallback` if you want cloud-only failure behavior.
+## Capabilities
 
-Hosted Hugging Face API calls usually do not return token logits, so `important_tokens` may be empty and `confidence` may be `0.0` unless your endpoint returns token-level details. When the local fallback runs, those fields are computed the same way as `infer_local.py`.
+* Code generation
+* Code debugging
+* Code explanation
+* Structured output generation
+* Confidence estimation
+* Hallucination detection
 
-### Cloud Output Guarantee
+---
 
-To make other users receive this JSON pattern with their own token, deploy this repository as a Hugging Face Dedicated Inference Endpoint. The included `handler.py` is loaded by the endpoint and returns:
+## Output Schema
 
 ```json
 {
@@ -204,60 +72,210 @@ To make other users receive this JSON pattern with their own token, deploy this
   "important_tokens": [],
   "relevancy_score": 0.0,
   "hallucination": false,
-  "hallucination_check_reason": "string",
+  "hallucination_check_reason": "",
   "latency_ms": 0
 }
 ```
 
-Endpoint request example:
+---
+
+## Training Details
+
+### Dataset
+
+* Size: ~5K–10K samples
+* Instruction-based coding dataset
+
+### Training Procedure
+
+* Method: LoRA fine-tuning
+* Framework: Transformers + PEFT
+* Precision: FP16 / Mixed
+
+### Training Hyperparameters
+
+| Parameter           | Value |
+| ------------------- | ----- |
+| Epochs              | 1–3   |
+| Batch Size          | 2     |
+| Learning Rate       | 2e-4  |
+| Max Sequence Length | 512   |
+| LoRA Rank (r)       | 8     |
+| LoRA Alpha          | 16    |
+| LoRA Dropout        | 0.05  |
+
+---
+
+## Inference Configuration
+
+```text
+max_new_tokens = 200
+temperature = 0.2
+top_p = 0.9
+do_sample = True
+```
+
+---
+
+## 🧪 How to Use This Model (Colab / Local)
+
+```python
+!pip -q install -U transformers peft accelerate huggingface_hub safetensors
+
+from google.colab import userdata
+HF_TOKEN = userdata.get('HF_TOKEN') 
+model = "girish00/ConicAI_LLM_model"
+prompt = input("Please enter your prompt: ")
+
+from huggingface_hub import login, snapshot_download
+login(token=HF_TOKEN)
+
+repo = snapshot_download(model, token=HF_TOKEN)
+
+import sys
+sys.path.append(repo)
 
-```powershell
-$env:HF_TOKEN="their_huggingface_token"
-Invoke-RestMethod `
-  -Uri "https://your-endpoint-url.endpoints.huggingface.cloud" `
-  -Method Post `
-  -Headers @{ Authorization = "Bearer $env:HF_TOKEN" } `
-  -ContentType "application/json" `
-  -Body '{"inputs":"Fix this code: def add(a,b) return a+b","parameters":{"max_new_tokens":320}}'
+from infer_local import build_instruction_prompt, build_structured_result
+from peft import PeftConfig, PeftModel
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import torch, time, json
+
+cfg = PeftConfig.from_pretrained(repo)
+base = cfg.base_model_name_or_path
+
+tokenizer = AutoTokenizer.from_pretrained(base)
+base_model = AutoModelForCausalLM.from_pretrained(
+    base,
+    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+    device_map="auto"
+)
+llm = PeftModel.from_pretrained(base_model, repo)
+llm.eval()
+
+inputs = tokenizer(build_instruction_prompt(prompt), return_tensors="pt").to(llm.device)
+
+start = time.perf_counter()
+with torch.no_grad():
+    out = llm.generate(
+        **inputs,
+        max_new_tokens=320,
+        output_scores=True,
+        return_dict_in_generate=True,
+        do_sample=False,
+        pad_token_id=tokenizer.eos_token_id
+    )
+latency = int((time.perf_counter() - start) * 1000)
+
+gen_ids = out.sequences[0][inputs["input_ids"].shape[1]:].tolist()
+text = tokenizer.decode(gen_ids, skip_special_tokens=True)
+
+conf = []
+for tid, score in zip(gen_ids, out.scores):
+    probs = torch.softmax(score[0], dim=-1)
+    conf.append(float(probs[tid].item()))
+
+print(json.dumps(
+    build_structured_result(
+        prompt,
+        text,
+        latency,
+        tokenizer=tokenizer,
+        generated_ids=gen_ids,
+        token_confidences=conf
+    ),
+    indent=2
+))
 ```
 
-Calling the model repository directly through Hugging Face serverless inference is not enough if Hugging Face has no provider serving the custom repo. Use a Dedicated Inference Endpoint or your own cloud VM for true cloud execution.
-
-Explicit base model for LoRA adapter loading:
-
-```python
-python infer_local.py --model-path model --base-model Qwen/Qwen2.5-Coder-0.5B-Instruct --prompt "Fix this code: def add(a,b) return a+b"
-```
-
-`infer_local.py` automatically handles both:
-- LoRA adapter output folders
-- Fully merged/full-model output folders
-
-## Accuracy Evaluation
-
-Run default evaluation prompts:
-
-```bash
-python evaluate_model.py --model-path model
-```
-
-Run with custom prompts:
-
-```bash
-python evaluate_model.py --model-path model --prompt "Fix this code: if x = 5: print(x)" --prompt "Write python code for linear regression and explain it"
-```
-
-For higher quality output:
-- use dataset size `8000` or `10000`
-- use `epochs >= 3`
-- prefer `--use-4bit` when GPU is available
-- keep prompts specific and task-focused
-
-## Recommended Run Order
-
-```bash
-python run_pipeline.py --dataset-size 8000 --skip-upload
-python infer_local.py --model-path model --prompt "Fix this code: def add(a,b) return a+b"
-python evaluate_model.py --model-path model
-python upload_to_hf.py --model-dir model --repo-id your-username/your-existing-model-name
-```
+---
+
+## Evaluation
+
+* Syntax validation
+* Prompt-based testing
+* Relevancy scoring
+* Hallucination detection
+
+---
+
+## Strengths
+
+* Lightweight and efficient
+* Strong performance on structured prompts
+* Generates readable and correct Python code
+* Provides reasoning-aware outputs
+
+---
+
+## Limitations
+
+* Sensitive to prompt structure
+* Confidence scores are heuristic
+* Limited generalization beyond training dataset
+
+---
+
+## Risks & Considerations
+
+* Always validate generated code
+* Not suitable for critical production systems
+* May produce incorrect logic
+
+---
+
+## Best Practices
+
+```
+Instruction:
+Input:
+Output:
+```
+
+* Use clear and specific prompts
+* Keep temperature low for reliability
+* Apply post-processing for cleaner output
+
+---
+
+## Technical Specifications
+
+* Transformer-based causal language model
+* LoRA adaptation on attention layers
+* Hugging Face Transformers + PEFT
+
+---
+
+## Environmental Impact
+
+* Uses parameter-efficient fine-tuning
+* Lower compute compared to full fine-tuning
+* Suitable for local deployment
+
+---
+
+## Intended Use
+
+### Direct Use
+
+* Coding assistant
+* Debugging support
+* Learning programming
+
+### Out-of-Scope Use
+
+* Security-critical systems
+* Autonomous production deployment
+
+---
+
+## Author
+
+**GIRISH KUMAR DEWANGAN**
+
+---
+
+## License
+
+Apache License 2.0
+
+---