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

Libraries

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

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

pipe = pipeline("text-generation", model="cotulabs/CoTuGRM-2.5.T1-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.T1-SFT")
model = AutoModelForMultimodalLM.from_pretrained("cotulabs/CoTuGRM-2.5.T1-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.T1-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.T1-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.T1-SFT",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

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

SGLang

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

Docker Model Runner
How to use cotulabs/CoTuGRM-2.5.T1-SFT with Docker Model Runner:
```
docker model run hf.co/cotulabs/CoTuGRM-2.5.T1-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.T1-SFT

Neuro-symbolic Z3 reasoning backbone for logic-based 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 1 — Logic-Based Educational Queries of the EXACT 2026 challenge.

Model Details

This checkpoint is the Task 1 backbone of the CoTu neuro-symbolic pipeline. The model does not give an answer directly. The model writes a Z3 solver program (Program-of-Thought) from the natural-language premises and the query. The Z3 solver runs the program and gives an entailment verdict. This verdict is the basis for the deduction. A Chain-of-Thought step then makes the final JSON output. The output contains the answer, the explanation, the premises_used list, and the reasoning steps. The model can process the three Task 1 formats: Yes/No/Uncertain, multiple-choice, and open-ended.


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,055 Task 1 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 Z3/Python program.

Stage	Items
Official logic-query release	808
After clarity filter (403 YNU / 314 MCQ / 5 OE)	722
+ synthesized open-ended (Z3-verified)	333
Total	1,055

The clarity filter removes items that have missing symbol definitions or references that are not clear. The filtered set had only a small number of open-ended items. Thus, the teacher model made more open-ended items. We kept a new open-ended item only if the Z3 solver confirmed its answer.

Dataset: minhnguyent546/EXACT-2026-CoTu (Task 1 SFT config: EXACT2026_dataset_2026-05-16-Logic_Based_Educational_Queries_Text_Only-deepseek_v4_pro_annotations-v3.1-b4a0136-with_extra_content).

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	$2 \times 10^{-4}$
LR schedule / warmup ratio	cosine / 0.03
Batch size / device	1
Gradient accumulation	4
Epochs	1
Weight decay	0.01
Optimizer	adamw_torch_fused
Precision	BF16

Evaluation

The full CoTu pipeline got 21.24 of 25 points for Task 1 in round 1 and 23.10 of 25 points in round 2 on the automated leaderboard. Team CoTu got the third place overall and the highest technical score in the final round. The most frequent error for Task 1 is incorrect premise selection. The deduction steps are usually correct.

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 1 educational logic QA in the CoTu neuro-symbolic pipeline (see the instructions here), together with a Z3 solver. 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}
}