uaytug/ucoder-mini-GGUF

uCoder-mini-GGUF

Quantized GGUF models converted from uaytug/ucoder-mini.

Converted using the latest llama.cpp (CUDA-accelerated quantization).

Available Files

16-bit

• —ucoder-mini-BF16.gguf → Highest precision float (similar to original, ~3 GB)

8-bit

• —ucoder-mini-Q8_0.gguf → Near-lossless

6-bit

• —ucoder-mini-Q6_K.gguf

5-bit

• —ucoder-mini-Q5_K_S.gguf
• —ucoder-mini-Q5_K_M.gguf → Great quality

4-bit (most popular range)

• —ucoder-mini-Q4_K_M.gguf → Recommended balance
• —ucoder-mini-Q4_K_S.gguf
• —ucoder-mini-Q4_1.gguf
• —ucoder-mini-IQ4_XS.gguf
• —ucoder-mini-IQ4_NL.gguf

3-bit

• —ucoder-mini-Q3_K_S.gguf
• —ucoder-mini-Q3_K_M.gguf
• —ucoder-mini-IQ3_XXS.gguf

2-bit

• —ucoder-mini-Q2_K.gguf
• —ucoder-mini-IQ2_M.gguf

Original Model Information

uCoder Mini

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.).

Overview

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)

Model Details

Intended Use

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

from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "uaytug/ucoder-mini"

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype="auto",
    device_map="auto"
)

messages = [
    {"role": "user", "content": "Write a Python function to find the longest palindromic substring."}
]

text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(text, return_tensors="pt").to(model.device)

outputs = model.generate(
    **inputs,
    max_new_tokens=1024,
    temperature=0.6,
    top_p=0.95,
    do_sample=True
)

response = tokenizer.decode(outputs[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True)
print(response)

Recommended Generation Parameters

For best results on coding tasks:

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 coding question here<|im_end|>
<|im_start|>assistant

Training Data

Trained on UCDS (uCoder Dataset) — a curated collection of 420K+ high-quality samples:

Total: 420,686 deduplicated samples covering Python, JavaScript, C++, Java, and more.

Limitations

• —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>Algorithm Problem</b></summary>

Prompt: Implement a function to find the kth largest element in an unsorted array.

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>

Prompt: Prove that the sum of the first n odd numbers equals n².

Response:

Let's prove this by multiple methods:

Method 1: Direct Calculation The first n odd numbers are: 1, 3, 5, ..., (2n-1)

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?

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. 1.Integer division: mid = (left + right) / 2 returns a float. Use // for integer division.

1. 1.Infinite loop: left = mid can cause infinite loop when mid == left. Should be left = mid + 1.

1. 1.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:

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

Citation

@misc{ucoder-mini,
  author = {uaytug},
  title = {uCoder Mini: A Compact Language Model for Code and Math},
  year = {2026},
  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.