CoTuGRM-2.5.T2-SFT

Instructions to use cotulabs/CoTuGRM-2.5.T2-SFT with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use cotulabs/CoTuGRM-2.5.T2-SFT with Transformers:

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

pipe = pipeline("text-generation", model="cotulabs/CoTuGRM-2.5.T2-SFT")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
pipe(text=messages)

# Load model directly
from transformers import AutoProcessor, AutoModelForMultimodalLM

processor = AutoProcessor.from_pretrained("cotulabs/CoTuGRM-2.5.T2-SFT")
model = AutoModelForMultimodalLM.from_pretrained("cotulabs/CoTuGRM-2.5.T2-SFT", device_map="auto")
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
inputs = processor.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=40)
print(processor.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use cotulabs/CoTuGRM-2.5.T2-SFT with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/cotulabs/CoTuGRM-2.5.T2-SFT

SGLang

How to use cotulabs/CoTuGRM-2.5.T2-SFT 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 "cotulabs/CoTuGRM-2.5.T2-SFT" \
    --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": "cotulabs/CoTuGRM-2.5.T2-SFT",
		"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 "cotulabs/CoTuGRM-2.5.T2-SFT" \
        --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": "cotulabs/CoTuGRM-2.5.T2-SFT",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use cotulabs/CoTuGRM-2.5.T2-SFT with Docker Model Runner:
```
docker model run hf.co/cotulabs/CoTuGRM-2.5.T2-SFT
```

You need to agree to share your contact information to access this model

This repository is publicly accessible, but you have to accept the conditions to access its files and content.

CoTuGRM-2.5.T2-SFT

Program-of-Thought physics reasoning backbone for numeric educational QA

Model Details · Training Data · Training Procedure · Evaluation · Uses

This model is a supervised fine-tune of OrionLLM/GRM-2.5. The base model has 4B parameters and uses the Qwen3.5 architecture. Team CoTu made this model for Task 2 — Physics Problems of the EXACT 2026 challenge.

Model Details

This checkpoint is the Task 2 backbone of the CoTu neuro-symbolic pipeline. The model receives only the raw text of the physics question. The input has no premises and no formula sheet. The model finds the applicable physical laws in its parametric memory. Then the model writes a Python program that uses SciPy for the physical constants. A sandboxed interpreter runs the program to calculate the numeric answer and the unit. For open-ended items, the pipeline runs three parallel Chain-of-Thought instances at different temperatures. The pipeline then aggregates the three results into the final JSON output. The model can process the YNU, multiple-choice, and numerical formats. The covered domains are circuits/electrostatics, mechanics, rotational dynamics, thermodynamics, and geometric optics.


Developed by	Team CoTu (CoTuLabs)
Model type	Decoder-only causal LM (Qwen3.5 architecture, `qwen3_5`), fine-tuned with LoRA (merged)
Language	English
License	GNU GPL v3.0
Finetuned from	`OrionLLM/GRM-2.5`
Parameters	~4B (within the EXACT 2026 8B open-weight ceiling)
Precision	BF16 (no quantization)

Training Data

We trained the model on 1,452 Task 2 items. An offline teacher model (DeepSeek-V4-Pro) made new annotations with reasoning traces for these items. The teacher model was not a competitor in the challenge. Each item has a thinking trace, an answer, an explanation, and a Python program. The premises_used field lists the applied physical laws.

Stage	Items
Official physics set	1,352
+ synthesized MCQs (Qwen3.6-27B)	100
Total	1,452

A second offline teacher model (Qwen3.6-27B) made the 100 multiple-choice items from questions that had only a numerical format. This teacher model was also not a competitor in the challenge. These new items increase the coverage of the answer formats.

Dataset: minhnguyent546/EXACT-2026-CoTu (Task 2 SFT config: EXACT2026_dataset_2026-05-15-Physics_Problems_Text_Only-with_synthesized_mcqa_100-val_361-depseek_v4_pro_annotations-v1.0).

Training Procedure

We used LoRA supervised fine-tuning. The loss calculation includes only the assistant's reasoning trace (<think>...</think>) and the final response. The prompt tokens are masked. After the training, we merged the adapters into the base weights. This repository contains the merged checkpoint.

Hyperparameter	Value
Method	LoRA (rank-stabilized, merged post-training)
LoRA rank / alpha / dropout	16 / 32 / 0.0
Target modules	q_proj, k_proj, v_proj, o_proj, gate_proj, up_proj, down_proj
Learning rate	$1 \times 10^{-4}$
LR schedule / warmup ratio	cosine / 0.03
Batch size / device	2
Gradient accumulation	4
Epochs	1
Weight decay	0.01
Optimizer	adamw_torch_fused
Precision	BF16

Evaluation

The full CoTu pipeline got a perfect score of 25 of 25 points for Task 2 in the two automated rounds. The solver gave a correct answer for each item in all three rounds. Team CoTu got the third place overall and the highest technical score in the final round.

Uses

Use this model with the CoTu repository from version v0.3.2 (included) to version v0.5.0 (excluded). The inference suite in these versions uses the system prompt from training. Versions outside this range can change the system prompt and reduce model performance.

Use this model for Task 2 physics QA in the CoTu neuro-symbolic pipeline (see the instructions here), together with a sandboxed Python interpreter. The model can also operate without the pipeline. But the model is trained to make structured program-of-thought output. This output must go to a downstream interpreter for execution.

Sampling parameters

During the challenge, we used the official recommended sampling parameters from Qwen/Qwen3.5-4B:

Mode	Task type	Sampling parameters
Thinking	General tasks	`temperature=1.0, top_p=0.95, top_k=20, min_p=0.0, presence_penalty=1.5, repetition_penalty=1.0`
Thinking	Precise coding tasks	`temperature=0.6, top_p=0.95, top_k=20, min_p=0.0, presence_penalty=0.0, repetition_penalty=1.0`
Non-Thinking (Instruct)	General tasks	`temperature=0.7, top_p=0.8, top_k=20, min_p=0.0, presence_penalty=1.5, repetition_penalty=1.0`
Non-Thinking (Instruct)	Reasoning tasks	`temperature=1.0, top_p=1.0, top_k=40, min_p=0.0, presence_penalty=2.0, repetition_penalty=1.0`

We recommend a maximum output length of 32,768 tokens for most queries. Use 49,152 tokens for complex tasks, for example math and programming competitions.

Citation

If you find this work useful in your research, please cite the following paper:

@article{tran2026cotu,
  title={CoTu at EXACT 2026: Neuro-Symbolic Reasoning for Transparent Educational QA},
  author={Tran, Quoc-Khang and Nguyen, Minh-Thien and Thai, Phu-An and Bui, Xuan-Tung and Ma, Truong-Thanh and Pham, Nguyen-Khang},
  journal={arXiv preprint arXiv:2607.14735},
  year={2026}
}