Update README.md

README.md

@@ -9,6 +9,7 @@ tags:
   - reasoning
   - text-generation
   - conversational
+  - qwen2
 pipeline_tag: text-generation
 library_name: transformers
 datasets:
@@ -20,23 +21,51 @@ model-index:
 
 # uCoder Mini
 
-<div align="center">
-  <img src="https://img.shields.io/badge/Parameters-1.5B-blue" alt="Parameters"> <img src="https://img.shields.io/badge/Context-4096-green" alt="Context Length"> <img src="https://img.shields.io/badge/License-Apache%202.0-orange" alt="License">
-</div>
+> **Important:** The model is unable to produce accurate and high-quality answers to general knowledge, creative writing, or non-coding tasks, and to questions asked in languages other than English. The answers to your questions in these areas may not be satisfactory because this model was specifically trained for **coding and mathematical reasoning tasks** (competitive programming, LeetCode, algorithm problems, etc.).
+
+![Parameters](https://img.shields.io/badge/Parameters-1.5B-blue) ![Architecture](https://img.shields.io/badge/Architecture-Qwen2-purple) ![Context](https://img.shields.io/badge/Context-4096-green) ![Precision](https://img.shields.io/badge/Precision-bfloat16-red) ![License](https://img.shields.io/badge/License-Apache%202.0-orange)
 
 ## Overview
 
-**uCoder Mini** is a compact 1.5B parameter language model fine-tuned for code generation and mathematical reasoning. Despite its small size, it delivers strong performance on programming tasks across multiple languages and competitive programming challenges.
+**uCoder Mini** is a 1.5B parameter dense language model fine-tuned specifically for code generation and mathematical reasoning. Built on the Qwen2 architecture, this model demonstrates that small, focused models can achieve strong performance on programming tasks when trained on high-quality, curated data.
+
+### Key Features
+
+- **Specialized Focus**: Trained exclusively on coding and math data for maximum performance in these domains
+- **Efficient Size**: 1.5B parameters — runs on consumer GPUs, fast inference
+- **Extended Context**: Supports up to 4096 tokens for longer code generation
+- **Multi-Language**: Handles Python, JavaScript, C++, Java, and more
+- **Competitive Programming**: Strong on algorithmic problems (LeetCode, Codeforces-style)
 
-Trained on the [UCDS (uCoder Dataset)](https://huggingface.co/datasets/uaytug/UCDS) — a curated collection of 420K+ high-quality coding and mathematics samples.
+## Model Details
+
+| Attribute | Value |
+|-----------|-------|
+| **Architecture** | Qwen2 (Dense Transformer) |
+| **Parameters** | ~1.5B |
+| **Hidden Size** | 1536 |
+| **Layers** | 28 |
+| **Attention Heads** | 12 |
+| **Context Length** | 4096 tokens |
+| **Vocabulary Size** | 151,936 |
+| **Training Precision** | bfloat16 |
+| **Training Method** | Supervised Fine-Tuning (SFT) |
 
 ## Intended Use
 
-- **Code generation** across Python, JavaScript, C++, Java, and more
-- **Competitive programming** problem solving
-- **Mathematical reasoning** and problem breakdown
-- **Code explanation** and debugging assistance
-- **Learning companion** for programming concepts
+**Recommended for:**
+- Competitive programming (LeetCode, Codeforces, HackerRank)
+- Algorithm implementation and optimization
+- Mathematical problem solving with code
+- Code debugging and explanation
+- Learning programming concepts
+
+**Not recommended for:**
+- General conversation or chat
+- Creative writing or storytelling
+- Factual Q&A or knowledge retrieval
+- Non-English tasks
+- Production systems without human review
 
 ## Quick Start
 
@@ -61,9 +90,9 @@ inputs = tokenizer(text, return_tensors="pt").to(model.device)
 
 outputs = model.generate(
     **inputs,
-    max_new_tokens=512,
-    temperature=0.7,
-    top_p=0.9,
+    max_new_tokens=1024,
+    temperature=0.6,
+    top_p=0.95,
     do_sample=True
 )
 
@@ -71,89 +100,191 @@ response = tokenizer.decode(outputs[0][inputs["input_ids"].shape[1]:], skip_spec
 print(response)
 ```
 
+### Recommended Generation Parameters
+
+For best results on coding tasks:
+
+```python
+generation_config = {
+    "max_new_tokens": 2048,
+    "temperature": 0.6,      # Use 0.6 for focused output, 1.0 for more exploration
+    "top_p": 0.95,
+    "do_sample": True,
+}
+```
+
 ## Chat Template
 
 uCoder Mini uses the ChatML format:
 
 ```
 <|im_start|>user
-Your question here<|im_end|>
+Your coding question here<|im_end|>
 <|im_start|>assistant
 ```
 
-## Training Details
+## Training Data
 
-| Attribute | Value |
-|-----------|-------|
-| **Training Dataset** | [uaytug/UCDS](https://huggingface.co/datasets/uaytug/UCDS) |
-| **Dataset Size** | 420,686 samples |
-| **Training Method** | Supervised Fine-Tuning (SFT) |
-| **Precision** | bfloat16 |
-| **Context Length** | 4096 tokens |
-
-### Dataset Composition
+Trained on [UCDS (uCoder Dataset)](https://huggingface.co/datasets/uaytug/UCDS) — a curated collection of 420K+ high-quality samples:
 
-The UCDS dataset combines high-quality sources:
+| Source | Samples | Description |
+|--------|---------|-------------|
+| Codeforces | 47K+ | Competitive programming with solutions |
+| Code-Contests-Plus | 10K+ | Algorithm challenges |
+| CodeAlpaca | 15K+ | Instruction-following code |
+| OpenMathInstruct | Various | Mathematical reasoning chains |
+| Curated Sources | Various | Tool use, chain-of-thought, deduplication |
 
-| Source | Description |
-|--------|-------------|
-| CodeForces | Competitive programming problems |
-| Code-Contests-Plus | Algorithm challenges with solutions |
-| CodeAlpaca | Instruction-following code samples |
-| OpenMathInstruct | Mathematical reasoning chains |
-| Additional curated sources | Tool use, chain-of-thought examples |
+**Total**: 420,686 deduplicated samples covering Python, JavaScript, C++, Java, and more.
 
 ## Limitations
 
-- **Model size**: As a 1.5B model, it may struggle with highly complex multi-file projects
-- **Knowledge cutoff**: Training data has a knowledge cutoff; recent libraries/APIs may not be covered
-- **Verification needed**: Always review and test generated code before production use
-- **Language coverage**: Strongest in Python; other languages may have reduced quality
+- **Domain-Specific**: This model is trained only on code/math — it will perform poorly on general tasks
+- **English Only**: Best performance in English; other languages not supported
+- **Knowledge Cutoff**: May not know about recent libraries, frameworks, or API changes
+- **No Verification**: Always test generated code before use in production
+- **Context Limit**: 4096 tokens may not be enough for very large codebases
+- **No Web Access**: Cannot fetch documentation or search for solutions
 
 ## Example Outputs
 
 <details>
-<summary><b>Competitive Programming</b></summary>
+<summary><b>Algorithm Problem</b></summary>
 
-**Prompt:** Solve the two-sum problem efficiently.
+**Prompt:** Implement a function to find the kth largest element in an unsorted array.
 
-**Response:** 
 ```python
-def two_sum(nums, target):
-    seen = {}
-    for i, num in enumerate(nums):
-        complement = target - num
-        if complement in seen:
-            return [seen[complement], i]
-        seen[num] = i
-    return []
+import heapq
+
+def find_kth_largest(nums, k):
+    # Use a min-heap of size k
+    # Time: O(n log k), Space: O(k)
+    heap = []
+    for num in nums:
+        heapq.heappush(heap, num)
+        if len(heap) > k:
+            heapq.heappop(heap)
+    return heap[0]
+
+# Alternative: QuickSelect for O(n) average
+def quickselect(nums, k):
+    k = len(nums) - k  # Convert to kth smallest
+    
+    def partition(left, right, pivot_idx):
+        pivot = nums[pivot_idx]
+        nums[pivot_idx], nums[right] = nums[right], nums[pivot_idx]
+        store_idx = left
+        for i in range(left, right):
+            if nums[i] < pivot:
+                nums[store_idx], nums[i] = nums[i], nums[store_idx]
+                store_idx += 1
+        nums[right], nums[store_idx] = nums[store_idx], nums[right]
+        return store_idx
+    
+    left, right = 0, len(nums) - 1
+    while True:
+        pivot_idx = partition(left, right, right)
+        if pivot_idx == k:
+            return nums[k]
+        elif pivot_idx < k:
+            left = pivot_idx + 1
+        else:
+            right = pivot_idx - 1
 ```
 
 </details>
 
 <details>
-<summary><b>Mathematical Reasoning</b></summary>
+<summary><b>📐 Mathematical Reasoning</b></summary>
 
-**Prompt:** Find the time complexity of merge sort and explain why.
+**Prompt:** Prove that the sum of the first n odd numbers equals n².
+
+**Response:** 
 
-**Response:** Merge sort has O(n log n) time complexity. Here's why:
+Let's prove this by multiple methods:
 
-1. **Divide step**: The array is split in half recursively, creating log(n) levels
-2. **Merge step**: At each level, we process all n elements exactly once
-3. **Total**: n elements × log(n) levels = O(n log n)
+**Method 1: Direct Calculation**
+The first n odd numbers are: 1, 3, 5, ..., (2n-1)
 
-This holds for best, average, and worst cases, making merge sort consistently efficient.
+Sum = 1 + 3 + 5 + ... + (2n-1)
+
+This is an arithmetic sequence with:
+- First term a₁ = 1
+- Last term aₙ = 2n - 1  
+- Number of terms = n
+
+Sum = n × (first + last) / 2 = n × (1 + 2n - 1) / 2 = n × 2n / 2 = n²
+
+**Method 2: Induction**
+- Base case: n=1 → Sum = 1 = 1² ✓
+- Assume true for k: 1 + 3 + ... + (2k-1) = k²
+- For k+1: k² + (2(k+1)-1) = k² + 2k + 1 = (k+1)² ✓
+
+</details>
+
+<details>
+<summary><b>🐛 Debugging</b></summary>
+
+**Prompt:** Why does this code give wrong results?
+```python
+def binary_search(arr, target):
+    left, right = 0, len(arr)
+    while left < right:
+        mid = (left + right) / 2
+        if arr[mid] == target:
+            return mid
+        elif arr[mid] < target:
+            left = mid
+        else:
+            right = mid
+    return -1
+```
+
+**Response:** There are several bugs:
+
+1. **Integer division**: `mid = (left + right) / 2` returns a float. Use `//` for integer division.
+
+2. **Infinite loop**: `left = mid` can cause infinite loop when `mid == left`. Should be `left = mid + 1`.
+
+3. **Off-by-one**: With `right = len(arr)`, using `right = mid` is correct, but the initial range setup suggests you want `right = len(arr) - 1` with `left <= right`.
+
+**Fixed version:**
+```python
+def binary_search(arr, target):
+    left, right = 0, len(arr) - 1
+    while left <= right:
+        mid = (left + right) // 2
+        if arr[mid] == target:
+            return mid
+        elif arr[mid] < target:
+            left = mid + 1
+        else:
+            right = mid - 1
+    return -1
+```
 
 </details>
 
+## Hardware Requirements
+
+| Setup | VRAM Required | Notes |
+|-------|---------------|-------|
+| FP16/BF16 | ~4 GB | Full precision inference |
+| INT8 | ~2 GB | Quantized, minimal quality loss |
+| INT4 | ~1.5 GB | For very constrained environments |
+
 ## Citation
 
 ```bibtex
-@misc{ucoder-mini,
+@misc{ucoder-mini-2025,
   author = {uaytug},
-  title = {uCoder Mini: A Compact Code and Math Language Model},
+  title = {uCoder Mini: A Compact Language Model for Code and Math},
   year = {2025},
   publisher = {Hugging Face},
   url = {https://huggingface.co/uaytug/ucoder-mini}
 }
-```
+```
+
+## Acknowledgments
+
+Thanks to the open-source community and creators of the datasets that made UCDS possible.