mine:o1-nano

mine:o1-nano

A 124M-parameter GPT-2-style language model trained from scratch in JAX and Flax, with ONNX files for CPU use. It suits students and researchers who study small-model training.

Made by MineAITechnology on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

About

What it is: mine:o1-nano is a small language model in the GPT-2 style with 124 million parameters. MineAI Technology pre-trained it from scratch in JAX and Flax NNX on a TPU, then fine-tuned it in three supervised rounds. The card presents it as a transparent baseline and a teaching reference, and it publishes its failure modes openly. The "o1" in the name is the team's own numbering and has nothing to do with OpenAI.

Who it suits: It suits students, researchers and engineers who want to see a complete small-model pipeline, from data to serving on a CPU. It also works as a baseline to compare other 124M-parameter models against.

Title: Who might use it
Industry | Who uses it | How they use it | Example
Education | Students of language models | Study a from-scratch training recipe in JAX | Read the card's architecture and training notes
Research | Small-model researchers | Use it as a published baseline | Compare perplexity with other GPT-2-size models
Software | Developers testing CPU serving | Run a tiny model with ONNX Runtime | Load the quantized ONNX file on a small server

If you want an open-ended chat assistant, you can skip it. The card says it is not ready for free-text chat deployment.

Where to use it: The model comes as ONNX files for CPU use and as a JAX checkpoint for further training.

• ONNX Runtime on a CPU, with the quantized file as the fastest option
• JAX and Flax NNX, to continue training or fine-tune from the checkpoint
• Windows, macOS or Linux with Python

Title: Jobs it does
Use case | Who | What they get back
CPU text generation | Developers | Short text from a model small enough for a modest server
Training study | Learners | A worked example of pre-training and staged fine-tuning
Continued training | Researchers | A checkpoint to fine-tune further in JAX

How to set it up: You need Python with pip. For ONNX use, install the runtime and helper packages from the card's quick start. Then download the repository.

• Python with pip
• ONNX Runtime, transformers, numpy and huggingface_hub for the ONNX route
• JAX with Flax NNX, if you plan to continue training

1. Install the Python packages for the ONNX route.
2. Download the model files from Hugging Face.
3. Pick the ONNX file that matches your goal.

pip install onnxruntime transformers numpy huggingface_hub

pip install -U huggingface_hub
hf download MineAITechnology/mine-o1-nano

How to use it: Load an ONNX file with ONNX Runtime, then prompt the model using its special user and assistant tokens. The card's Python quick start is not shown in full here, so follow the card for the exact calls. Quantization can shift outputs slightly, so compare against the fp16 file if exact behavior matters.

Title: Which file to use
Goal | File
Lowest latency on a CPU | The quantized ONNX file
CPU output closest to the original | The fp16 ONNX file
Reference or debugging | The fp32 ONNX file
Continue training in JAX | The Orbax checkpoint

Example: You load the quantized ONNX file on a small CPU server and send a short prompt using the model's user and assistant tokens. You get a brief text reply. Expect modest quality, as the card is open about its limits.

For newcomers and experts: If you are new, this is a tiny relative of GPT-2 that you can run on an ordinary computer. Start with the quantized file and a short prompt, then judge the output for yourself.

If you know the field, it has 12 layers, 12 heads, a hidden size of 768 and a context of 1024 tokens, with tied embeddings. The vocabulary adds two special tokens to the GPT-2 base. The card admits that compressed and distilled GPT-2 variants beat it on zero-shot WikiText-103 perplexity.

Text is tokenized with the GPT-2 vocabulary
A 12-layer decoder processes the tokens
The model predicts the next token
The ONNX file runs on a CPU

Good to know: The files come in several precisions. Smaller files run faster on a CPU but can shift the output slightly.

Title: ONNX file sizes
fp32: 535 MB
fp16: 335 MB
Quantized: 134 MB

• License: Apache 2.0
• Cost to run: none named, and the card says the live demo runs on a small CPU instance
• Data it reaches: the model files from Hugging Face, and the prompts you give it
• Not for: open-ended chat deployment, reasoning tasks, or anything that needs a state-of-the-art model

On Hugging Face, 13 November 2026

• Task: text generation
• Library: flax
• Downloads in the last 30 days: 68
• Likes: 7
• License: apache-2.0
• Languages: en
• Tags: flax, onnx, gpt2, text-generation, from-scratch, small-language-model, causal-lm

Links

• Model: https://huggingface.co/MineAITechnology/mine-o1-nano
• Files: https://huggingface.co/MineAITechnology/mine-o1-nano/tree/main

Get the model

Download its files with Hugging Face's command line:

pip install -U huggingface_hub
hf download MineAITechnology/mine-o1-nano

Then follow the usage in its model card. Nothing in this kit runs by itself.