AmareshHebbar/leetcode-java-qwen25-coder-7b
<div align="center">
☕ LeetCode Java Coder
Qwen2.5-Coder-7B, QDoRA fine-tuned to solve LeetCode problems in Java
        
Part of the [LeetCode Multi-Language Coder Suite](https://huggingface.co/collections/AmareshHebbar/leetcode-multi-language-coder-suite) — 4 language specialists, one base model, one pipeline
</div>
TL;DR
Given a LeetCode-style problem statement, its sample input/output, and an algorithm tag, generates a working Java solution.
PROBLEM: Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.
ALGORITHM: Hash Map
OUTPUT (Java):
class Solution {
public int[] twoSum(int[] nums, int target) {
Map<Integer, Integer> seen = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
if (seen.containsKey(target - nums[i])) {
return new int[]{seen.get(target - nums[i]), i};
}
seen.put(nums[i], i);
}
return new int[]{};
}
}Why QDoRA {#why-qdora}
DoRA splits each adapted weight into magnitude + direction and trains both, which follows full fine-tuning's behavior more closely than plain LoRA — important for code where small precision errors break correctness outright. 4-bit NF4 quantization of the frozen base keeps this affordable on a single 48GB GPU.
Concretely, versus the plain-QLoRA v1 release of this suite: DoRA adds a per-column trainable magnitude vector on top of the usual low-rank direction update, so the adapter can rescale a feature's importance instead of only rotating it. On a code task where a single wrong operator or dropped edge case fails the whole solution, that closer match to full fine-tuning's update pattern showed up as fewer near-miss failures during our own qualitative review, at the same LoRA rank and VRAM budget.
# training-side PEFT config (see build_language_datasets.py / trainer script for full pipeline)
from peft import LoraConfig
peft_config = LoraConfig(
r=16,
lora_alpha=32,
lora_dropout=0.0,
target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
use_dora=True, # <- this is what makes it QDoRA, not QLoRA
task_type="CAUSAL_LM",
)Benchmarks (free, reproducible)
Run benchmark_suite.py from the deployment kit to reproduce. All numbers are pass@1 unless noted.
Numbers are intentionally left blank in this template —benchmark_suite.pyfills aresults/leetcode-java-qwen25-coder-7b.jsonfile and this table should be regenerated from it.
Intended use
Drop-in solution generator for Java coding-practice tools, interview-prep apps, and automated code-review sandboxes for algorithmic problems.
Direct use
Give a problem statement (+ optional algorithm hint), get back a Java function/class implementing it.
Downstream use
Feed output into an automated grader (run against test cases), a code-review bot, or a practice-app "show solution" feature.
Out of scope
- Production system design or non-algorithmic code (this model specializes narrowly on LeetCode-style problems)
- Security-critical code without human review
- Guaranteed-optimal complexity — treat output as a strong first draft, not a proof
Quickstart
Option A — Transformers + PEFT
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel
import torch
base_model = "unsloth/Qwen2.5-Coder-7B-Instruct"
adapter = "AmareshHebbar/leetcode-java-qwen25-coder-7b"
tokenizer = AutoTokenizer.from_pretrained("AmareshHebbar/leetcode-java-qwen25-coder-7b")
model = AutoModelForCausalLM.from_pretrained(
base_model,
torch_dtype=torch.bfloat16,
device_map="auto",
)
model = PeftModel.from_pretrained(model, adapter)
messages = [
{"role": "system", "content": "You are an expert Java competitive programmer. Given a LeetCode-style problem statement and an algorithm tag, write a correct, efficient Java solution."},
{"role": "user", "content": "Problem: Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.\nAlgorithm: Hash Map"},
]
inputs = tokenizer.apply_chat_template(messages, return_tensors="pt", add_generation_prompt=True).to(model.device)
outputs = model.generate(inputs, max_new_tokens=512, temperature=0.2, do_sample=True)
print(tokenizer.decode(outputs[0][inputs.shape[1]:], skip_special_tokens=True))Batch inference (many problems at once)
problems = [
"Problem: Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.\nAlgorithm: Hash Map",
"Problem: Given a string s, find the length of the longest substring without repeating characters.\nAlgorithm: two pointers / sliding window",
"Problem: Merge two sorted linked lists into one sorted list.\nAlgorithm: linked list, dummy head",
]
prompts = [
tokenizer.apply_chat_template(
[{"role": "system", "content": "You are an expert Java competitive programmer. Given a LeetCode-style problem statement and an algorithm tag, write a correct, efficient Java solution."}, {"role": "user", "content": p}],
tokenize=False, add_generation_prompt=True,
)
for p in problems
]
tokenizer.padding_side = "left"
batch = tokenizer(prompts, return_tensors="pt", padding=True).to(model.device)
outputs = model.generate(**batch, max_new_tokens=512, temperature=0.2, do_sample=True)
for i, o in enumerate(outputs):
print(f"--- solution {i} ---")
print(tokenizer.decode(o[batch['input_ids'].shape[1]:], skip_special_tokens=True))Streaming output (token-by-token)
from transformers import TextIteratorStreamer
from threading import Thread
streamer = TextIteratorStreamer(tokenizer, skip_prompt=True, skip_special_tokens=True)
gen_kwargs = dict(input_ids=inputs, max_new_tokens=512, temperature=0.2, do_sample=True, streamer=streamer)
Thread(target=model.generate, kwargs=gen_kwargs).start()
for token in streamer:
print(token, end="", flush=True)Structured JSON output (code + complexity + explanation)
json_system_prompt = (
"You are an expert Java competitive programmer. Given a LeetCode-style problem statement and an algorithm tag, write a correct, efficient Java solution. "
'Respond ONLY with JSON: {"code": "...", "time_complexity": "...", '
'"space_complexity": "...", "explanation": "..."}'
)
messages = [
{"role": "system", "content": json_system_prompt},
{"role": "user", "content": "Problem: Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.\nAlgorithm: Hash Map"},
]
inputs = tokenizer.apply_chat_template(messages, return_tensors="pt", add_generation_prompt=True).to(model.device)
outputs = model.generate(inputs, max_new_tokens=512, temperature=0.1, do_sample=True)
raw = tokenizer.decode(outputs[0][inputs.shape[1]:], skip_special_tokens=True)
import json
result = json.loads(raw.strip().removeprefix("```json").removesuffix("```").strip())
print(result["code"])
print(result["time_complexity"], result["space_complexity"])Option B — Unsloth (2x faster load + inference)
from unsloth import FastLanguageModel
model, tokenizer = FastLanguageModel.from_pretrained(
model_name="AmareshHebbar/leetcode-java-qwen25-coder-7b",
max_seq_length=2048,
load_in_4bit=True,
)
FastLanguageModel.for_inference(model)
messages = [
{"role": "system", "content": "You are an expert Java competitive programmer. Given a LeetCode-style problem statement and an algorithm tag, write a correct, efficient Java solution."},
{"role": "user", "content": "Problem: Given a string s, find the length of the longest substring without repeating characters.\nAlgorithm: two pointers / sliding window"},
]
prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens=512, temperature=0.2, do_sample=True)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True))Option C — vLLM (production serving, OpenAI-compatible) {#vllm}
vllm serve unsloth/Qwen2.5-Coder-7B-Instruct \
--enable-lora \
--lora-modules leetcode-java-qwen25-coder-7b=AmareshHebbar/leetcode-java-qwen25-coder-7b \
--host 0.0.0.0 --port 8000 --dtype bfloat16from openai import OpenAI
client = OpenAI(base_url="http://localhost:8000/v1", api_key="not-needed")
response = client.chat.completions.create(
model="leetcode-java-qwen25-coder-7b",
messages=[
{"role": "system", "content": "You are an expert Java competitive programmer. Given a LeetCode-style problem statement and an algorithm tag, write a correct, efficient Java solution."},
{"role": "user", "content": "Problem: Merge two sorted linked lists into one sorted list.\nAlgorithm: linked list, dummy head"},
],
temperature=0.2,
)
print(response.choices[0].message.content)Streaming with vLLM's OpenAI-compatible endpoint:
stream = client.chat.completions.create(
model="leetcode-java-qwen25-coder-7b",
messages=[{"role": "user", "content": "Problem: Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.\nAlgorithm: Hash Map"}],
stream=True,
)
for chunk in stream:
if chunk.choices[0].delta.content:
print(chunk.choices[0].delta.content, end="", flush=True)Option D — TGI (Text Generation Inference) {#tgi}
docker run --gpus all --shm-size 1g -p 8080:80 \
-v $PWD/data:/data ghcr.io/huggingface/text-generation-inference:latest \
--model-id unsloth/Qwen2.5-Coder-7B-Instruct \
--lora-adapters leetcode-java-qwen25-coder-7b=AmareshHebbar/leetcode-java-qwen25-coder-7bcurl 127.0.0.1:8080/generate_stream \
-X POST \
-d '{"inputs":"<|im_start|>system\nYou are an expert Java competitive programmer. Given a LeetCode-style problem statement and an algorithm tag, write a correct, efficient Java solution.<|im_end|>\n<|im_start|>user\nProblem: Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.\nAlgorithm: Hash Map<|im_end|>\n<|im_start|>assistant\n","parameters":{"max_new_tokens":512}}' \
-H 'Content-Type: application/json'Option E — Ollama (local, mobile/edge-friendly) {#ollama}
# 1. Pull the GGUF build
huggingface-cli download AmareshHebbar/leetcode-java-qwen25-coder-7b-GGUF leetcode-java-qwen25-coder-7b.q4_k_m.gguf --local-dir .
# 2. Create the model from the Modelfile shipped in the deployment kit (see deploy_ollama.py)
ollama create leetcode-java-qwen25-coder-7b -f Modelfile.java
# 3. Run it
ollama run leetcode-java-qwen25-coder-7b "Problem: Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.\nAlgorithm: Hash Map"Python client against a local Ollama server:
import requests
r = requests.post("http://localhost:11434/api/generate", json={
"model": "leetcode-java-qwen25-coder-7b",
"prompt": "Problem: Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.\nAlgorithm: Hash Map",
"stream": False,
})
print(r.json()["response"])Option F — GGUF / llama.cpp direct (mobile/edge inference)
./llama-cli -m leetcode-java-qwen25-coder-7b.q4_k_m.gguf \
-p "<|im_start|>system\nYou are an expert Java competitive programmer. Given a LeetCode-style problem statement and an algorithm tag, write a correct, efficient Java solution.<|im_end|>\n<|im_start|>user\nProblem: Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.<|im_end|>\n<|im_start|>assistant\n" \
-n 512 --temp 0.2See export_gguf.py in the deployment kit for building q4km / q5km / q8_0 variants, and the mobile integration notes there for Android (llama.cpp JNI) and iOS (llama.cpp via Swift bindings).
Training details
Why this base model
Qwen2.5-Coder-7B-Instruct was chosen over a general instruct model because its pretraining already concentrates capacity on code — the QDoRA adapter only has to specialize output format and LeetCode-specific conventions (function signatures, in-place vs. new-array conventions, Java idioms) rather than teach the model to code from scratch. 7B was picked as the size that still fits comfortably in a single-GPU QDoRA run while keeping enough headroom that the base model's code reasoning survives adaptation.
Data pipeline
Source: doocs/leetcode, 3,977 problems with English documentation. Each problem can have multiple solutions spanning different algorithm tags (greedy, DP, two pointers, etc.) — the pipeline treats this as a one-to-many problem-to-solution structure rather than picking a single "canonical" answer.
execution-checked against sample I/O (see dataset card for exact rate). Full extraction/verification/build code lives alongside the leetcode-codegen-java dataset card.
Hyperparameters
Training compute
Fine-tuned with Unsloth + TRL's SFTTrainer, DoRA enabled via PEFT.
Bias, risks & limitations
Narrow specialization. This model is tuned tightly on LeetCode-style algorithmic problems — general software-engineering code (frameworks, infra, business logic) is out of distribution.
Verify before trusting. Like any LLM, generated solutions can look plausible and still fail an edge case (empty input, integer overflow, off-by-one). Always run against test cases before use.
Not exhaustive on complexity. The model doesn't guarantee asymptotically optimal solutions — check the complexity claims yourself for performance-sensitive use.
Data recency. Reflects the state of doocs/leetcode at the time of extraction — newer problems added to LeetCode after that snapshot won't be covered.
FAQ
Q: Can I merge the adapter into the base model? Yes — model.merge_and_unload() after loading with PEFT, or Unsloth's save_pretrained_merged(). DoRA adapters merge the same way LoRA adapters do.
Q: Why QDoRA instead of plain QLoRA? See Why QDoRA above — short version: DoRA's magnitude/direction split tracks full fine-tuning more closely, which matters for code correctness.
Q: Why QDoRA instead of full fine-tuning? Qwen2.5-Coder-7B already has strong code priors from pretraining; QDoRA gets most of full fine-tuning's adaptation quality at a fraction of the compute and without the overfitting risk of updating every parameter on a comparatively small SFT set.
Q: Which quantization should I use on mobile? q4km is the best size/quality tradeoff for phones; q5km if you have RAM headroom; avoid q2/q3 for code generation — correctness drops sharply below 4-bit.
Q: Does this model store or transmit my input? No — inference runs entirely on whatever infrastructure you deploy it to.
Related models in this suite
Full collection: LeetCode Multi-Language Coder Suite
Changelog
Citation
@misc{leetcodecoder2026,
author = {Hebbar, Amaresh},
title = {LeetCode Multi-Language Coder Suite},
year = {2026},
publisher = {HuggingFace},
url = {https://huggingface.co/AmareshHebbar}
}Contact
  