Instructions to use jgalego/ada-coder-qwen2.5-1.5b with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use jgalego/ada-coder-qwen2.5-1.5b with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="jgalego/ada-coder-qwen2.5-1.5b")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("jgalego/ada-coder-qwen2.5-1.5b")
model = AutoModelForCausalLM.from_pretrained("jgalego/ada-coder-qwen2.5-1.5b", device_map="auto")
messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=256)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use jgalego/ada-coder-qwen2.5-1.5b with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "jgalego/ada-coder-qwen2.5-1.5b"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "jgalego/ada-coder-qwen2.5-1.5b",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/jgalego/ada-coder-qwen2.5-1.5b

SGLang

How to use jgalego/ada-coder-qwen2.5-1.5b with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "jgalego/ada-coder-qwen2.5-1.5b" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "jgalego/ada-coder-qwen2.5-1.5b",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "jgalego/ada-coder-qwen2.5-1.5b" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "jgalego/ada-coder-qwen2.5-1.5b",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use jgalego/ada-coder-qwen2.5-1.5b with Docker Model Runner:
```
docker model run hf.co/jgalego/ada-coder-qwen2.5-1.5b
```
Browse Quantizations to use this model in llama.cpp, Ollama, LM Studio, or any compatible app.

ada-coder-qwen2.5-1.5b

Qwen/Qwen2.5-Coder-1.5B-Instruct fine-tuned with LoRA to write Ada 2022 and SPARK code from a task description, spec or signature.

Review every line. The output is not qualified for DO-178C, EN 50128, ISO 26262 or any other certification process. Compile it, test it and, for SPARK, prove it before use.

🚀 Usage

from transformers import AutoModelForCausalLM, AutoTokenizer

repo = "jgalego/ada-coder-qwen2.5-1.5b"
tokenizer = AutoTokenizer.from_pretrained(repo)
model = AutoModelForCausalLM.from_pretrained(repo, dtype="auto")

messages = [
    {"role": "system", "content": "You write Ada 2022 and SPARK code that compiles cleanly with GNAT."},
    {"role": "user", "content": "Write a function that returns the greatest common divisor of two Positive numbers."},
]
inputs = tokenizer.apply_chat_template(
    messages,
    add_generation_prompt=True,
    return_tensors="pt",
    return_dict=True,
)
out = model.generate(**inputs, max_new_tokens=512, do_sample=False)
print(tokenizer.decode(out[0, inputs["input_ids"].shape[1] :], skip_special_tokens=True))

It also completes raw Ada source with no chat template, which is how it is scored below.

🏋️ Training


Base	Qwen/Qwen2.5-Coder-1.5B-Instruct
Data	`r7_dataset.jsonl` from the-clanker-lover/steelman-sft-ada, 6,110 instruction/code pairs that compile with GNAT
Method	LoRA, r=16, alpha=32, all linear layers, merged
Steps	756 (2.0 epochs), batch size 16, max length 2048
Learning rate	0.0002, cosine
Mean train loss	0.2271
Hardware	NVIDIA A10G, 94 min

Then GRPO on the MBPP-Ada problems in MultiPL-E (mbpp-adb), which share none with HumanEval-Ada. Each step samples 8 completions per problem from the raw prompt at temperature 0.8; GNAT builds and runs each against the problem's tests. Reward: 1 if it passes, 0.25 if it only compiles, 0 otherwise. LoRA r=16 on top of the previous model, merged after each round.

Round	Steps	Problems per step	Learning rate	Mean reward, first → last step	Hardware
1	45	8	2e-05	0.293 → 0.418	NVIDIA A10G, 39 min

📊 Results

nuprl/MultiPL-E HumanEval-Ada (humaneval-adb, 157 problems). Greedy decoding from the raw prompt, then built and run with the GNAT flags from MultiPL-E's eval_adb.py. A program passes when every pragma Assert holds.

Model	n	pass@1	Compile rate	Runtime errors	Timeouts
jgalego/ada-coder-qwen2.5-1.5b	157	0.223	0.682	71	1
jgalego/ada-coder-qwen2.5-1.5b@sft	157	0.204	0.592	61	0
Qwen/Qwen2.5-Coder-1.5B-Instruct	157	0.089	0.35	41	0
jgalego/ada-coder-qwen2.5-1.5b@grpo-2	157	0.204	0.694	77	0

Reference scores reported by the Steelman authors (model card, report) on the same benchmark with their own harness, temperature 0:

Model	pass@1	Compile rate
Steelman 14B v0.3 (Qwen2.5-Coder-14B + R7 data)	0.459	0.854
Steelman 14B v0.2 (Qwen2.5-Coder-14B-Instruct + R6 data)	0.471	0.752
Qwen2.5-Coder-14B, untuned	0.344	0.510

⚠️ Limitations

Scored on small HumanEval-style functions, not on full programs or packages.
Contracts are at most checked at run time (-gnata); nothing here runs GNATprove.
Trained on a single dataset; style follows that data.