my-python-coder

A LoRA fine-tune of Qwen2.5-Coder-1.5B-Instruct specialized for Python code generation.

This model was fine-tuned as a learning project to demonstrate the full workflow of taking a base model, training it on a custom dataset, and publishing it to the Hugging Face Hub.

Training Details

Parameter	Value
Base model	Qwen/Qwen2.5-Coder-1.5B-Instruct
Dataset	iamtarun/python_code_instructions_18k_alpaca (first 1,500 examples)
Method	LoRA (r=16, alpha=32, target_modules=all-linear)
Training steps	200
Learning rate	2e-4
Effective batch size	8 (batch=2 × grad_accum=4)
Max sequence length	1024
Hardware	Google Colab (NVIDIA T4, 16 GB VRAM)
Training time	~33 minutes

What Is This — A Model or an Adapter?

This repository contains a LoRA adapter, not a standalone model. Understanding the difference matters for how you load and use it.

The Two Artifacts

	Base Model	LoRA Adapter (this repo)
What it is	The full pretrained neural network	A small set of trained weights that modify the base
Size	~3 GB	~74 MB
Who made it	The Qwen team	Me (SathishKumar89)
Repo	Qwen/Qwen2.5-Coder-1.5B-Instruct	SathishKumar89/my-python-coder
Contains	All model weights, tokenizer, config	Only adapter weights + config + tokenizer copy
Loadable alone?	✅ Yes	❌ No — needs the base model

Why This Design?

Instead of retraining all ~1.5 billion parameters of the base model, LoRA (Low-Rank Adaptation) freezes the base model and only trains a tiny number of new parameters. This gives several advantages:

• Tiny file size — 74 MB vs. ~3 GB (a ~40× reduction)
• Fast training — minutes to hours instead of days
• Runs on modest hardware — a free Google Colab T4 GPU is enough
• Easy to swap — you can keep the same base model and load different adapters for different tasks

How to Load It Correctly

Because this repo is an adapter, you must load two things — the base model first, then the adapter on top:

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel
import torch

# Step 1: Load the base model
base = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen2.5-Coder-1.5B-Instruct",
    dtype=torch.float16,
    device_map="auto",
)

# Step 2: Attach the LoRA adapter
model = PeftModel.from_pretrained(base, "SathishKumar89/my-python-coder")

# Step 3: Load the tokenizer (included in this repo)
tokenizer = AutoTokenizer.from_pretrained("SathishKumar89/my-python-coder")

## Prompt Format

This model was trained with the following instruction format. Using the same format at inference time will give the best results:

Instruction:

Response:

<model's answer>

## Usage

```python
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
from peft import PeftModel

# Load base model and LoRA adapter
base_model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen2.5-Coder-1.5B-Instruct",
    dtype=torch.float16,
    device_map="auto",
)
model = PeftModel.from_pretrained(base_model, "SathishKumar89/my-python-coder")
tokenizer = AutoTokenizer.from_pretrained("SathishKumar89/my-python-coder")

# Prepare a prompt
prompt = """### Instruction:
Write a Python function that checks if a number is prime.

### Response:
"""

inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
outputs = model.generate(**inputs, max_new_tokens=200, do_sample=False)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Example Output

Prompt:

### Instruction:
Write a Python function that checks if a number is prime.

### Response:

Model output:

def is_prime(num):
    # Check for 0 and 1
    if num <= 1:
        return False

    # Check for even numbers greater than 2
    elif num == 2:
        return True
    elif num % 2 == 0:
        return False

    # Check for odd numbers greater than 3
    else:
        for i in range(3, int(num**0.5) + 1, 2):
            if num % i == 0:
                return False
        return True

Limitations

• Trained on a small subset (1,500 of 18,612 examples) for only 200 steps — this is a proof-of-concept, not a production model.
• May not generalize well to complex Python tasks (large refactors, multi-file projects, advanced libraries).
• Inherits any biases or limitations present in the base model and training dataset.
• Not evaluated against standard benchmarks.

Future Improvements

• Train on the full dataset for multiple epochs
• Increase LoRA rank for greater capacity
• Evaluate on HumanEval or MBPP benchmarks

Acknowledgements

• Base model: Qwen2.5-Coder-1.5B-Instruct by the Qwen team
• Dataset: iamtarun/python_code_instructions_18k_alpaca
• Training framework: Hugging Face transformers, peft, trl