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

Model card: animated header and links to the Quantile Labs pages

eac6ac0 verified about 12 hours ago

preview code

Raw History Blame Contribute Delete

8.69 kB

---
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
---
<p align="center"><a href="https://quantilelabs.com/wazocore/"><img src="https://huggingface.co/quantile-labs/WazoCore-8B/resolve/main/assets/wazocore-header.gif" alt="WazoCore: Nigeria's N-ATLaS, made faster and lighter for Yoruba, Hausa and Igbo. The same Yoruba sentence takes 60 tokens in N-ATLaS and 36 in WazoCore." width="100%"></a></p>

# WazoCore

[Model page](https://quantilelabs.com/wazocore/) · [Code and evaluation](https://github.com/Quantile-Labs/wazocore) · [Quantile Labs](https://quantilelabs.com/): Africa's open AI models, made smarter, faster and lighter.

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](https://huggingface.co/quantile-labs/WazoCore-8B-v6-long).
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](https://quantilelabs.com/) |
| 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](#licence)) |
| Code and evaluation | [github.com/Quantile-Labs/wazocore](https://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.

```sh
pip install transformers accelerate
```

```python
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.

```sh
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`](https://github.com/Quantile-Labs/wazocore/blob/main/docs/METHOD.md).

## Training

1. **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.
2. **Initialisation.** New embeddings are initialised from the mean of their
   constituent subword embeddings.
3. **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.

	---
	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
	---

	<p align="center"><a href="https://quantilelabs.com/wazocore/"><img src="https://huggingface.co/quantile-labs/WazoCore-8B/resolve/main/assets/wazocore-header.gif" alt="WazoCore: Nigeria's N-ATLaS, made faster and lighter for Yoruba, Hausa and Igbo. The same Yoruba sentence takes 60 tokens in N-ATLaS and 36 in WazoCore." width="100%"></a></p>

	# WazoCore

	[Model page](https://quantilelabs.com/wazocore/) · [Code and evaluation](https://github.com/Quantile-Labs/wazocore) · [Quantile Labs](https://quantilelabs.com/): Africa's open AI models, made smarter, faster and lighter.

	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](https://huggingface.co/quantile-labs/WazoCore-8B-v6-long).
	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](https://quantilelabs.com/) \|
	\| 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](#licence)) \|
	\| Code and evaluation \| [github.com/Quantile-Labs/wazocore](https://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.

	```sh
	pip install transformers accelerate
	```

	```python
	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.

	```sh
	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`](https://github.com/Quantile-Labs/wazocore/blob/main/docs/METHOD.md).

	## Training

	1. 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.
	2. Initialisation. New embeddings are initialised from the mean of their
	constituent subword embeddings.
	3. 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.