AutoDevvLM

AutoDevvLM is a small, code-focused language model fine-tuned from Qwen2.5-1.5B-Instruct. It was trained with QLoRA on general code-instruction data and is distributed in GGUF format for local inference with llama.cpp, Ollama, LM Studio and similar tools.

Note: AutoDevvLM is a fine-tune of Qwen2.5-1.5B-Instruct. It is not an independent model, and it may still identify itself as Qwen unless given a system prompt (see Usage).

Model Details

Developed by	Vivek A
Base model	Qwen/Qwen2.5-1.5B-Instruct
Architecture	Qwen2 (Qwen2ForCausalLM), ~1.5B parameters
Context length	32,768 tokens in the architecture; training used sequences up to 1,024 tokens
Fine-tuning method	Supervised fine-tuning (SFT) with QLoRA
Language	English (primary)
License	Apache 2.0
Format	GGUF (quantized)

Files

File	Description	Approx. size
AutoDevvLM-Q4_K_M.gguf	4-bit quantized, recommended for most local use	~1 GB
AutoDevvLM-f16.gguf (optional)	Full FP16 precision	~3 GB

Intended Use

AutoDevvLM is intended for lightweight, local coding assistance:

• Writing short functions and scripts
• Explaining code and simple debugging
• Answering general programming questions
• Experimentation and learning about fine-tuning small models

Out-of-Scope Use

• Safety-critical or production-critical code generation without human review
• Security-sensitive tasks (generated code may contain vulnerabilities)
• Factual, legal, medical or financial advice
• Use as a general-purpose assistant for tasks far outside programming

Usage

The model uses the Qwen (ChatML) chat format. The template is embedded in the GGUF, so most runtimes apply it automatically.

llama.cpp

llama-cli -m AutoDevvLM-Q4_K_M.gguf -cnv \
  -sys "You are AutoDevvLM, a helpful coding assistant."

Ollama

Create a Modelfile:

FROM ./AutoDevvLM-Q4_K_M.gguf
SYSTEM """You are AutoDevvLM, a coding assistant. Help with writing, debugging and explaining code."""
PARAMETER temperature 0.2

Then:

ollama create autodevvlm -f Modelfile
ollama run autodevvlm

Python (llama-cpp-python)

from llama_cpp import Llama

llm = Llama(model_path="AutoDevvLM-Q4_K_M.gguf", n_ctx=4096)

out = llm.create_chat_completion(
    messages=[
        {"role": "system", "content": "You are AutoDevvLM, a helpful coding assistant."},
        {"role": "user", "content": "Write a Python function that checks whether a string is a valid IPv4 address."},
    ],
    max_tokens=400,
    temperature=0.2,
    top_p=0.95,
)
print(out["choices"][0]["message"]["content"])

Suggested sampling settings: temperature 0.2 to 0.4, top_p 0.95 for code.

Training Details

Training data

m-a-p/CodeFeedback-Filtered-Instruction (Apache 2.0). A random subset of 8,000 examples was used after filtering out examples longer than 1,024 tokens, with a 2% hold-out for evaluation loss. Each example was formatted with the Qwen chat template (user query, assistant answer).

Training procedure

Setting	Value
Method	QLoRA (4-bit NF4 with double quantization, via bitsandbytes)
Compute precision	FP16 (BF16 not used; NVIDIA T4 lacks native BF16)
LoRA rank / alpha / dropout	16 / 32 / 0.05
LoRA target modules	q_proj, k_proj, v_proj, o_proj, gate_proj, up_proj, down_proj
Epochs	1
Batch size	2 per device x 8 gradient accumulation (effective 16)
Learning rate	2e-4, cosine schedule, 3% warmup
Optimizer	paged_adamw_8bit
Max grad norm	0.3
Max sequence length	1,024
Gradient checkpointing	Enabled
Hardware	Google Colab, 1x NVIDIA Tesla T4 (16 GB)
Frameworks	Transformers, PEFT, TRL, bitsandbytes

Export

The LoRA adapter was merged into the FP16 base model, converted to GGUF with llama.cpp's convert_hf_to_gguf.py, and quantized to Q4_K_M with llama-quantize.

Evaluation

No formal benchmark evaluation has been run for this model yet. Results on HumanEval, MBPP or similar benchmarks have not been measured, and no claim is made that it outperforms the base model. Users are encouraged to compare outputs against Qwen2.5-1.5B-Instruct on their own tasks.

Limitations and Risks

• Small model: at 1.5B parameters it can produce incorrect, incomplete or insecure code, and may hallucinate APIs or library functions. Always review and test its output.
• Light fine-tune: training used 8,000 examples for a single epoch, so behavior is close to the base model, with modest changes in code style and explanation format.
• Identity: the training data contained no identity examples, so the model may state that it is Qwen. Use a system prompt to set the assistant name.
• Quantization: Q4_K_M trades some quality for size; use the F16 file if you need maximum fidelity.
• Inherited biases: the model inherits the limitations and biases of the base model and the training dataset.
• Language coverage: performance is strongest in English and in popular programming languages.

License

Released under the Apache 2.0 license, the same as the base model and the training dataset. Please retain the license notice and attribution when redistributing.

Acknowledgements

• Qwen Team for the base model, Qwen2.5-1.5B-Instruct
• m-a-p for the CodeFeedback-Filtered-Instruction dataset
• llama.cpp, PEFT, TRL and bitsandbytes

Citation

@misc{autodevvlm2026,
  title  = {AutoDevvLM: A QLoRA fine-tune of Qwen2.5-1.5B-Instruct for code assistance},
  author = {<your-name-or-org>},
  year   = {2026},
  howpublished = {\url{https://huggingface.co/<your-username>/AutoDevvLM}}
}