OmniEdu

Curriculum-aware, multimodal models for the full K–12 learning–teaching loop. OmniEdu brings together subject knowledge, curriculum alignment, learner diagnosis, and instructional support in three model scales: 4B, 9B, and 27B, each available in BF16 and FP8.

📄 Paper (arXiv) · 🌐 Project page · 🤗 Models · 🤗 Dataset · 🛠️ Toolkit

Hao Liang · Qihan Lin · Meiyi Qiang · Linzhuang Sun · Hengyi Feng · Mingrui Chen · Sizhe Qiu · Wentao Zhang
Peking University · University of the Chinese Academy of Sciences · Zhongguancun Academy

October 2026: FP8 checkpoints are available at all three scales, with 37%–44% smaller weight downloads and per-benchmark BF16/FP8 comparisons. Choose a checkpoint · Compare FP8 results.

September 2026: Paper, model weights, and training data are available. Original BF16 results follow arXiv v1, submitted September 19, 2026.

An educational model needs to connect what is being taught, what the learner understands, and what to do next. OmniEdu organizes supervised fine-tuning around four complementary capabilities:

The training mixture contains 69,999 instruction examples and 15.96M supervised response tokens, drawn from more than 100 sources: 60,951 education-specific examples and 9,048 general-purpose examples, with task-specific system instructions. The models use full-parameter supervised fine-tuning with a 32,768-token training sequence length.

Sizes are the summed .safetensors file sizes on Hugging Face (rounded, checked October 7, 2026), not total runtime GPU memory. Allow additional memory for the KV cache, activations, vision inputs, and serving overhead.

All six checkpoints use Qwen3_5ForConditionalGeneration. Choose BF16 for the original release or FP8 for a smaller checkpoint and quantized serving with a compatible backend. Training uses the qwen3_5_nothink template; keep enable_thinking=False.

The FP8 releases use LLM Compressor and compressed-tensors with the FP8_BLOCK scheme: 128×128 block-wise FP8 weights and dynamic FP8 activations in groups of 128. The vision tower, linear-attention in_proj_a/b projections, and lm_head remain unquantized; other non-Linear modules retain their original dtype. The tokenizer, architecture, and chat template are unchanged. See each FP8 model card for its quantization recipe and configuration.

This section reports the original BF16 checkpoints from the paper. Quantized-checkpoint results appear in FP8 evaluation.

Across the paper's 16-model comparison, OmniEdu-27B leads K12-Bench EM/F1, MathFish accuracy, and LongTutor's teaching score. It reaches 86.95% EDUMATH MaC and 78.74% MathTutorBench Scaffold win rate, second among evaluated models on these two metrics. The comparisons include education-specific open-weight models and GPT-5.4, GPT-5.6-Sol, Claude-Opus-5, GLM-5.3, and Kimi-K3.

Each OmniEdu scale improves over its corresponding backbone on all summary metrics in the three education tables:

Scores reproduce arXiv v1 (Tables 1–3); higher is better. Values are percentages except LongTutor-T, which uses the original teaching-score scale. MathTutor-S / SH denote Scaffold / Scaffold-hard win rates; LongTutor-E / T denote Evidence / Teaching averages. The five education-specific baselines and GLM-5.3 receive text-only inputs on image-dependent examples, as described in the paper. Rankings apply to the evaluation protocol reported in the paper.

The selected overall metrics below improve at all three scales. Individual submetrics can be flat or decline; see Detailed results for all IFEval, GPQA, and MMMU-Pro results.

Sources: IFEval, Table 13, GPQA, Table 14, MMMU-Pro, Table 15. All values are percentages.

The following results are published in the FP8 model cards, alongside the original BF16 scores. They are separate from the paper's 16-model ranking. Quantization produces both increases and decreases across metrics; these are point estimates, not evidence of statistical equivalence.

Higher is better. Values are percentages except LongTutor-T (Teaching), which uses the original score scale. MathTutor-S / SH are Scaffold / Scaffold-hard win rates; LongTutor-E is Evidence.

Sources: 4B FP8 model card · 9B FP8 model card · 27B FP8 model card.

For the original BF16 checkpoints, use a recent Transformers release with Qwen3.5 support and a GPU setup with sufficient memory for the chosen checkpoint. The example starts with 4B; change MODEL_ID for 9B or 27B.

pip install -U torch torchvision transformers accelerate safetensors pillow

import torch
from transformers import AutoProcessor, Qwen3_5ForConditionalGeneration

MODEL_ID = "lhpku20010120/Omni-Edu-4B"  # or Omni-Edu-9B / Omni-Edu-27B
processor = AutoProcessor.from_pretrained(MODEL_ID)
model = Qwen3_5ForConditionalGeneration.from_pretrained(
    MODEL_ID,
    dtype=torch.bfloat16,
    device_map="auto",
).eval()

messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "text",
                "text": "A Grade 7 student says summer is warmer because Earth is closer to the Sun. Identify the misconception and give a guiding question before explaining.",
            }
        ],
    }
]
inputs = processor.apply_chat_template(
    messages,
    add_generation_prompt=True,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    enable_thinking=False,
).to(model.device)

with torch.inference_mode():
    outputs = model.generate(**inputs, max_new_tokens=512, do_sample=False)

answer = processor.batch_decode(
    outputs[:, inputs["input_ids"].shape[-1]:],
    skip_special_tokens=True,
)[0]
print(answer)

For image-based questions, include an image item such as {"type": "image", "image": "/path/to/question.png"} alongside the text item in content. The processor prepares both modalities. See the official Qwen3.5 Transformers documentation for supported input formats.

Loading an FP8 checkpoint with Transformers: install compressed-tensors in addition to the dependencies above and change MODEL_ID to an -FP8 model ID. Transformers may decompress these weights during execution; a smaller download does not by itself guarantee lower inference memory. For serving this block-wise FP8 format, use the vLLM example below. See Transformers loading modes.

Install a current vLLM release with Qwen3.5 support in a separate environment from the Transformers example, then launch a BF16 checkpoint:

pip install -U vllm

vllm serve lhpku20010120/Omni-Edu-4B \
  --served-model-name omniedu-4b \
  --dtype bfloat16 \
  --tensor-parallel-size 1 \
  --max-model-len 32768 \
  --reasoning-parser qwen3 \
  --default-chat-template-kwargs '{"enable_thinking": false}'

Replace the model ID for 9B or 27B and set --tensor-parallel-size to the number of GPUs used for the model. If you change the model size, also change --served-model-name to omniedu-9b or omniedu-27b so it matches the corresponding SDK alias. Required GPU memory also depends on context length, concurrency, and vision inputs; reduce --max-model-len if needed. The serving configuration follows the official vLLM Qwen3.5 guide.

On a GPU/backend that supports block-wise FP8, launch the published FP8 checkpoint directly:

vllm serve lhpku20010120/Omni-Edu-4B-FP8 \
  --served-model-name omniedu-4b \
  --dtype bfloat16 \
  --tensor-parallel-size 1 \
  --max-model-len 32768 \
  --reasoning-parser qwen3 \
  --default-chat-template-kwargs '{"enable_thinking": false}'

Replace the ID with lhpku20010120/Omni-Edu-9B-FP8 or lhpku20010120/Omni-Edu-27B-FP8 as needed, and update the served model name accordingly. vLLM reads the checkpoint's compressed-tensors quantization configuration automatically; --dtype bfloat16 sets the compute dtype for unquantized components and does not convert the stored FP8 weights to BF16. Set GPU parallelism and context length to fit your hardware. Both BF16 and FP8 servers use the same API request below.

Query the running server from another terminal:

curl http://localhost:8000/v1/chat/completions \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "omniedu-4b",
    "messages": [{"role": "user", "content": "Help a student solve x^2 - 5x + 6 = 0. Start with a hint."}],
    "temperature": 0.2,
    "max_tokens": 512,
    "chat_template_kwargs": {"enable_thinking": false}
  }'

Load the released instruction mixture from Hugging Face:

pip install -U datasets

from datasets import load_dataset

train = load_dataset(
    "lhpku20010120/Omni-Edu",
    "core_v6_full_system_prompted",
    split="train",
)
print(train)

The dataset covers curriculum grounding, problem solving, diagnosis, tutoring, and general instruction. Please follow the licenses and usage terms of the component datasets and source materials.

This repository includes the data preparation and training code, along with a Python toolkit for using and evaluating OmniEdu models.

The omniedu Python package provides a unified interface for OmniEdu models and other models served through OpenAI-compatible APIs. Its evaluation suite supports 12 educational and general-purpose benchmarks, with tools for scoring open-ended responses and generating Markdown comparison tables.

Install from PyPI:

pip install omniedu

With the 4B vLLM service launched above, you can make a request through the SDK:

from omniedu import OmniEdu

model = OmniEdu.from_pretrained("4B", base_url="http://127.0.0.1:8000/v1")
response = model.chat(text="Help a student solve x^2 - 5x + 6 = 0. Start with a hint.")
print(response.text)

To explore the evaluation suite:

pip install "omniedu[eval]"
omniedu eval --list

See the toolkit README for image inputs, task-specific instructions, JSONL batch inference, evaluation of your own models, and report generation. Benchmark datasets and upstream code must be obtained separately where required.

For training, see the training README. To inspect the configuration without launching a run:

bash training/run_training.sh 9b --dry-run

The code is licensed under Apache-2.0. Model weights and third-party datasets and benchmarks retain their respective licenses.

OmniEdu supports research, educational prototypes, and teacher-assistance tools. Benchmark performance does not establish classroom learning gains. Models can give incorrect answers or unsuitable guidance; educators should review outputs before consequential use. The paper discusses evaluation coverage, multimodal limitations, and deployment considerations in more detail.

@misc{liang2026omniedu,
  title         = {OmniEdu: Open Foundation Models for Learning and Teaching},
  author        = {Hao Liang and Qihan Lin and Meiyi Qiang and Linzhuang Sun and Hengyi Feng and Mingrui Chen and Sizhe Qiu and Wentao Zhang},
  year          = {2026},
  eprint        = {2609.23088},
  archivePrefix = {arXiv},
  primaryClass  = {cs.CL},
  url           = {https://arxiv.org/abs/2609.23088}
}

We thank the authors and maintainers of the underlying models, datasets, benchmarks, and the LLaMA-Factory ecosystem.