Instructions to use quantile-labs/WazoCore-8B with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use quantile-labs/WazoCore-8B with Transformers:

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

pipe = pipeline("text-generation", model="quantile-labs/WazoCore-8B")
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("quantile-labs/WazoCore-8B")
model = AutoModelForCausalLM.from_pretrained("quantile-labs/WazoCore-8B", 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

llama.cpp

How to use quantile-labs/WazoCore-8B with llama.cpp:

Install (macOS, Linux)

curl -LsSf https://llama.app/install.sh | sh
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf quantile-labs/WazoCore-8B:Q4_K_M
# Run inference directly in the terminal:
llama cli -hf quantile-labs/WazoCore-8B:Q4_K_M

Install from WinGet (Windows)

winget install llama.cpp
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf quantile-labs/WazoCore-8B:Q4_K_M
# Run inference directly in the terminal:
llama cli -hf quantile-labs/WazoCore-8B:Q4_K_M

Build from source code

git clone https://github.com/ggml-org/llama.cpp.git
cd llama.cpp
cmake -B build
cmake --build build -j --target llama-app
# Start a local OpenAI-compatible server with a web UI:
./build/bin/llama serve -hf quantile-labs/WazoCore-8B:Q4_K_M
# Run inference directly in the terminal:
./build/bin/llama cli -hf quantile-labs/WazoCore-8B:Q4_K_M

Use Docker

docker model run hf.co/quantile-labs/WazoCore-8B:Q4_K_M

Llama new
LM Studio
Jan

vLLM

How to use quantile-labs/WazoCore-8B with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/quantile-labs/WazoCore-8B:Q4_K_M

SGLang

How to use quantile-labs/WazoCore-8B 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 "quantile-labs/WazoCore-8B" \
    --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": "quantile-labs/WazoCore-8B",
		"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 "quantile-labs/WazoCore-8B" \
        --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": "quantile-labs/WazoCore-8B",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Ollama
How to use quantile-labs/WazoCore-8B with Ollama:
```
ollama run hf.co/quantile-labs/WazoCore-8B:Q4_K_M
```
Unsloth Desktop

How to use quantile-labs/WazoCore-8B with Pi:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf quantile-labs/WazoCore-8B:Q4_K_M

Configure the model in Pi

# Install Pi:
npm install -g @earendil-works/pi-coding-agent
# Add to ~/.pi/agent/models.json:
{
  "providers": {
    "llama-cpp": {
      "baseUrl": "http://localhost:8080/v1",
      "api": "openai-completions",
      "apiKey": "none",
      "models": [
        {
          "id": "quantile-labs/WazoCore-8B:Q4_K_M"
        }
      ]
    }
  }
}

Run Pi

# Start Pi in your project directory:
pi

Docker Model Runner
How to use quantile-labs/WazoCore-8B with Docker Model Runner:
```
docker model run hf.co/quantile-labs/WazoCore-8B:Q4_K_M
```

Lemonade

How to use quantile-labs/WazoCore-8B with Lemonade:

Pull the model

# Download Lemonade from https://lemonade-server.ai/
lemonade pull quantile-labs/WazoCore-8B:Q4_K_M

Run and chat with the model

lemonade run user.WazoCore-8B-Q4_K_M

List all available models

lemonade list

Hermes Agent

How to use quantile-labs/WazoCore-8B with Hermes Agent:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf quantile-labs/WazoCore-8B:Q4_K_M

Configure Hermes

# Install Hermes:
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
hermes setup
# Point Hermes at the local server:
hermes config set model.provider custom
hermes config set model.base_url http://127.0.0.1:8080/v1
hermes config set model.default quantile-labs/WazoCore-8B:Q4_K_M

Run Hermes

hermes

Atomic Chat

OpenClaw

How to use quantile-labs/WazoCore-8B with OpenClaw:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf quantile-labs/WazoCore-8B:Q4_K_M

Configure OpenClaw

# Install OpenClaw:
npm install -g openclaw@latest
# Register the local server and set it as the default model:
openclaw onboard --non-interactive --mode local \
  --auth-choice custom-api-key \
  --custom-base-url http://127.0.0.1:8080/v1 \
  --custom-model-id "quantile-labs/WazoCore-8B:Q4_K_M" \
  --custom-provider-id llama-cpp \
  --custom-compatibility openai \
  --custom-text-input \
  --accept-risk \
  --skip-health

Run OpenClaw

openclaw agent --local --agent main --message "Hello from Hugging Face"

WazoCore-8B / README.md

mkbadeniyi

Align interval with summary

1d5adad verified 2 days ago

preview code

Raw History Blame Contribute Delete

8.12 kB

metadata

license: other
license_name: n-atlas-open-source-research-and-innovation-license
base_model: NCAIR1/N-ATLaS
base_model_relation: finetune
language:
  - yo
  - ha
  - ig
  - en
pipeline_tag: text-generation
library_name: transformers
datasets:
  - google/smol
  - openai/gsm8k
metrics:
  - chrf
  - accuracy
tags:
  - yoruba
  - hausa
  - igbo
  - nigerian-languages
  - african-languages
  - low-resource-languages
  - vocabulary-expansion
  - tokenizer
  - translation
  - llama-3
  - llama-cpp
  - gguf
  - safetensors

WazoCore

WazoCore is an 8B language model for Yoruba, Hausa and Igbo, adapted from N-ATLaS with 15,000 additional tokens for the three languages. It encodes them in roughly a third fewer tokens than its base model, making generation 1.6 to 1.7 times faster on commodity hardware, and is a drop-in replacement in Transformers, llama.cpp, LM Studio and OpenAI-compatible stacks.

This release, v13, supersedes WazoCore v6. It retains v6's efficiency and translation quality and recovers most of the reasoning lost in vocabulary adaptation.

Change from v6	v6	v13
Mathematical reasoning (AfriMGSM), vs base model	−11.6	+0.9 (−2.3, +4.3)
Natural-language inference (AfriXNLI), vs base model	−7.5	−4.8
Degenerate repetition, 750 test translations	5	0
Truncated outputs, 750 test translations	11	5
Decomposed Unicode input	efficiency lost	normalised (NFC)

Model details


Developer	Quantile Labs
Base model	NCAIR1/N-ATLaS (Llama-3 architecture, 8B parameters)
Licensed name	WazoCore Powered by Awarri.
Vocabulary	143,256 tokens: the base model's 128,256, unchanged in id and embedding, plus 15,000 for Yoruba, Hausa and Igbo
Release files	`model.safetensors` (BF16, 16.3 GB) with tokenizer and configuration; `WazoCore-8B.Q4_K_M.gguf` (5.0 GB)
Languages	Yoruba, Hausa, Igbo, English
Licence	N-ATLaS Open-Source Research and Innovation License (details)
Code and evaluation	github.com/Quantile-Labs/wazocore

Motivation. The base model inherits the Llama-3 tokenizer, which was trained predominantly on English. A Yoruba word requires about 2.9 tokens, against 1.3 for an English word, which raises latency, serving cost and context consumption for every Nigerian-language request. WazoCore adds word and subword tokens for the three languages while leaving English tokenisation effectively unchanged.

Usage

Transformers. The repository is a standard LlamaForCausalLM checkpoint; the tokenizer applies NFC normalisation automatically.

pip install transformers accelerate

from transformers import AutoModelForCausalLM, AutoTokenizer

repo = "quantile-labs/WazoCore-8B"
tok = AutoTokenizer.from_pretrained(repo)
model = AutoModelForCausalLM.from_pretrained(repo, dtype="bfloat16", device_map="auto")

messages = [{"role": "user", "content": "Translate into Hausa: The clinic opens at eight in the morning."}]
inputs = tok.apply_chat_template(messages, add_generation_prompt=True, return_dict=True, return_tensors="pt").to(model.device)
out = model.generate(**inputs, max_new_tokens=128)
print(tok.decode(out[0, inputs["input_ids"].shape[1]:], skip_special_tokens=True))

llama.cpp. The GGUF is validated in llama.cpp and LM Studio.

hf download quantile-labs/WazoCore-8B WazoCore-8B.Q4_K_M.gguf --local-dir .
llama-server -m WazoCore-8B.Q4_K_M.gguf -c 4096 --port 8080
curl -s localhost:8080/v1/chat/completions -H "Content-Type: application/json" \
  -d '{"messages":[{"role":"user","content":"Translate into Hausa: The clinic opens at eight in the morning."}]}'

Set the context size explicitly with -c; otherwise llama-server allocates memory for the 131,072-token maximum declared in the file. The model runs offline on machines with 8 GB of memory or more.

Intended use

Generation and translation of Yoruba, Hausa and Igbo text on local or on-premise hardware, as a replacement for the base model where tokenisation cost constrains latency, cost or context length. Use is subject to the licence terms below.

Evaluation

All comparisons are against the base model. Intervals are 95% paired bootstrap confidence intervals.

WazoCore vs base model	Yoruba	Hausa	Igbo
Tokens per word	2.87 → 1.91	2.12 → 1.34	2.53 → 1.56
Generation speed-up (words/s), laptop CPU	1.63×	1.61×	1.72×
ΔchrF++, English → X, Q4_K_M	+3.4 (+2.2, +4.6)	−0.6 (−1.4, +0.3)	+0.1 (−1.3, +1.3)
ΔchrF++, English → X, held-out	+2.2 (+1.6, +2.8)	−0.4 (−0.9, 0.0)	+0.1 (−0.5, +0.7)
ΔchrF++, X → English, held-out	+0.2 (−0.4, +0.7)	−0.1 (−0.5, +0.4)	+0.9 (+0.5, +1.4)
AfriMGSM accuracy (WazoCore / base)	37.2 / 33.6	40.4 / 38.8	25.6 / 28.0
AfriXNLI accuracy (WazoCore / base)	52.3 / 57.7	54.2 / 57.5	53.0 / 58.8

Speed. llama.cpp build 9430, Q4_K_M, Apple M4 CPU, 20 prompts per language, paired and interleaved, measured with the v6 release, which shares v13's tokenizer and token efficiency. Per-token decoding throughput is equivalent for both models; the speed-up derives entirely from shorter token sequences.
Translation, Q4_K_M. Both quantised models in llama.cpp, 250 NTREX-128 sentences per language.
Translation, held-out. 1,497 NTREX-128 sentences per language reserved from all training and model-selection decisions, full precision, same training recipe.
Reasoning. IrokoBench, zero-shot, chat template, full precision. Pooled over the three languages: AfriMGSM +0.9 (−2.3, +4.3), AfriXNLI −4.8 (−6.9, −2.7).

Full protocol and reproduction commands: docs/METHOD.md.

Training

Vocabulary extension. 15,000 byte-level BPE merges learned on Yoruba, Hausa and Igbo text and appended to the base tokenizer. Merges that would split a UTF-8 character are excluded. Input is normalised to Unicode NFC.
Initialisation. New embeddings are initialised from the mean of their constituent subword embeddings.
Fine-tuning. Approximately 80 minutes on a single A100. Only the new embedding rows and four of 32 transformer layers are updated. Original vocabulary rows are frozen, and a KL-divergence term anchors predictions to the base model.

Data	Volume
Base-model translations of Wikipedia sentences, English to and from each language	~24,000 requests
google/smol professional translations (CC BY 4.0)	23,662 sentence pairs
Self-distilled GSM8K solutions in Yoruba, Hausa, Igbo and English, retained only when the final answer is correct	5,831 solutions
Yoruba, Hausa and Igbo Wikipedia, filtered for orthographic quality	15% of training tokens

Decontamination. Training items sharing any 13-gram with IrokoBench, FLORES-200 or NTREX-128 are removed.

Limitations

WazoCore is optimised for generation and translation in Yoruba, Hausa and Igbo. For workloads dominated by natural-language inference, the base model scores higher on AfriXNLI. Evaluation covers translation and reasoning; validate open-ended dialogue on representative prompts before deployment.

Licence

WazoCore is a derivative of N-ATLaS and is released under the N-ATLaS Open-Source Research and Innovation License (Terms of Use v1.0). N-ATLaS is an initiative of the Federal Ministry of Communications, Innovation and Digital Economy, powered by Awarri Technologies. Principal terms:

this attribution must be retained;
renamed derivatives must end in "Powered by Awarri." and carry the same licence;
use is limited to 1,000 monthly active end-users without a commercial licence;
surveillance, discriminatory profiling, disinformation, military use and unauthorised personal-data scraping are prohibited.

Consult the full terms on the N-ATLaS model page before use.