One 384-dimensional vector for every word in vocabradar/wordfreq: 42 languages, 1,672,738 words. The word lists and the vector matrices are row-for-row aligned, so a word's line number in the list is also its row in the matrix and its frequency rank.

Vectors come from hotchpotch/bekko-embedding-v1-a25m — a 24.9M-parameter multilingual ModernBERT encoder (MIT), mean pooling, L2-normalized, 384 dimensions (Matryoshka 256 / 128 / 64). Inference runs on llama.cpp with the official BF16 GGUF (--embedding --pooling mean --embd-normalize 2, Vulkan GPU offload). Each normalized vector is then quantized to int8 with scale 127, which keeps the whole dataset at about 612 MiB while preserving cosine similarity to within ~0.001.

中文版请见下方：中文版说明

Files

WordEmbedding/
├── README.md                  # this card, bilingual
├── meta.json                  # model, format, per-language counts
├── files.json                 # size + SHA-256 of every data file
├── tools/
│   ├── build_dataset.py       # embed (llama.cpp) + finalize (meta/files)
│   ├── gen_readme.py          # regenerate the generated tables below
│   └── verify.py              # re-check sizes, SHA-256, row alignment
└── data/
    ├── <lang>.words.txt       # UTF-8 words, one per line, frequency order
    └── <lang>.int8.vector    # int8 vectors, row-major, N × 384

One pair of files per language (en, zh, ar, … — 42 in total).

Data format

For a language xx:

<xx>.words.txt — plain UTF-8, one word per line, in cleaned wordfreq order (descending frequency). Line i (0-based) has frequency rank i + 1.
<xx>.int8.vector — raw int8, row-major, shape N × 384, no header. Row i is the vector of line i in the words file.
N = file size / 384.
Dequantize with v = int8 / 127.0. Rows were L2-normalized before quantization, so the result is close to unit length.
Cosine similarity: dot(a, b) / 127² after casting to float32 or int32. Do not call numpy.dot directly on two int8 arrays — the accumulator overflows for 384 dimensions.

Quick start

import numpy as np

words = open("data/en.words.txt", encoding="utf-8").read().splitlines()
vec = np.memmap("data/en.int8.vector", dtype=np.int8, mode="r").reshape(-1, 384)
q = vec.astype(np.float32) / 127.0          # N × 384, approximately unit length

i = words.index("apple")
sims = q @ q[i]                            # cosine similarities
for j in np.argsort(-sims)[1:11]:
    print(f"{words[j]:20s} {sims[j]:.4f}")

The same matrix works across languages: apple is close to 苹果, pomme, Apfel, and so on, because bekko is a multilingual model.

Precision

int8 quantization was measured on 1,000 English words:

metric	value
cosine (float32 ↔ int8), min / mean	0.99885 / 0.99902
top-10 neighbour overlap (200 queries)	98.3%

That is well below the semantic spacing between unrelated words and is the reason the dataset can ship at 384 bytes per word. If you need higher fidelity, rebuild with a different SCALE/dtype in tools/build_dataset.py.

meta.json → languages.<code>.zero_vectors records how many rows are all zero (words that produced no model tokens); see the per-language entries.

Model and build

item	value
base model	`hotchpotch/bekko-embedding-v1-a25m` (MIT)
GGUF	`hotchpotch/bekko-embedding-v1-a25m-GGUF`, `BF16`, 252,522,944 bytes, SHA-256 `f85eda97…93d559`
architecture	ModernBERT, 24.9M active parameters
output	384 dimensions, mean pooling, L2-normalized
context	8192 tokens (words are far shorter)
runtime	llama.cpp `llama-server --embedding` (Vulkan GPU offload)

# 1) place the GGUF in work/models/ (auto-downloaded from hf-mirror if absent)
# 2) point at your llama.cpp build if it is not BrowserExtention/backend/bin/llamacpp
python tools/build_dataset.py all
# or a subset / a re-run
python tools/build_dataset.py embed --langs en zh --force
python tools/build_dataset.py finalize

build_dataset.py starts (or reuses) a local llama-server, posts batches of 2048 words to /v1/embeddings (base64 float32 responses), and fsyncs every batch to data/<lang>.int8.vector.part, with progress in work/parts/<lang>.json. An interrupted run resumes at the last durable batch instead of redoing the whole language; the .part is renamed to <lang>.int8.vector only after the final batch. On a Vulkan GPU this sustains roughly 700–1,200 words/s, so the full 42-language run takes tens of minutes, not hours. Exact provenance (model hash, llama.cpp build, per-language backend) is recorded in meta.json.

Two disjoint language sets can run as separate tasks on different ports, for example a GPU worker and a CPU worker:

python tools/build_dataset.py embed --langs ta ru sk --port 18083 --gpu-layers 99
python tools/build_dataset.py embed --langs lt tr fi --port 18085 --gpu-layers 0 --threads 8

Languages

code	language	native name	words	vectors (MiB)
ar	Arabic	العربية	55,611	20.37
bg	Bulgarian	български	35,848	13.13
bn	Bengali	বাংলা	33,062	12.11
ca	Catalan	català	27,028	9.90
cs	Czech	čeština	51,744	18.95
da	Danish	dansk	29,321	10.74
de	German	Deutsch	38,989	14.28
el	Greek	Ελληνικά	43,191	15.82
en	English	English	28,223	10.34
es	Spanish	español	34,740	12.72
fa	Persian	فارسی	30,108	11.03
fi	Finnish	suomi	59,143	21.66
fil	Filipino	Filipino	30,098	11.02
fr	French	français	31,203	11.43
he	Hebrew	עברית	57,405	21.02
hi	Hindi	हिन्दी	24,031	8.80
hu	Hungarian	magyar	46,525	17.04
id	Indonesian	Bahasa Indonesia	30,967	11.34
is	Icelandic	íslenska	42,207	15.46
it	Italian	italiano	35,954	13.17
ja	Japanese	日本語	27,856	10.20
ko	Korean	한국어	26,807	9.82
lt	Lithuanian	lietuvių	63,973	23.43
lv	Latvian	latviešu	45,464	16.65
mk	Macedonian	македонски	32,925	12.06
ms	Malay	Bahasa Melayu	28,571	10.46
nb	Norwegian Bokmål	norsk bokmål	25,994	9.52
nl	Dutch	Nederlands	28,715	10.52
pl	Polish	polski	49,664	18.19
pt	Portuguese	português	33,123	12.13
ro	Romanian	română	43,279	15.85
ru	Russian	русский	59,604	21.83
sh	Serbo-Croatian	srpskohrvatski / српскохрватски	54,698	20.03
sk	Slovak	slovenčina	59,414	21.76
sl	Slovenian	slovenščina	53,882	19.73
sv	Swedish	svenska	30,515	11.17
ta	Tamil	தமிழ்	64,756	23.71
tr	Turkish	Türkçe	63,130	23.12
uk	Ukrainian	українська	46,286	16.95
ur	Urdu	اردو	22,442	8.22
vi	Vietnamese	Tiếng Việt	10,519	3.85
zh	Chinese	中文	35,723	13.08
total	42 languages	—	1,672,738	612.57

words is the number of vectors in that language; vectors is the size of the .int8.vector file. The total row sums both columns.

Licence and citation

The embedding model is MIT-licensed. The word lists are derived from vocabradar/wordfreq (MIT metadata; upstream wordfreq 3.0.2). If you use this dataset, cite the model and the word list:

@misc{bekko_embedding_v1_a25m,
  title  = {bekko-embedding-v1-a25m},
  author = {hotchpotch},
  year   = {2026},
  url    = {https://huggingface.co/hotchpotch/bekko-embedding-v1-a25m}
}
@misc{vocabradar_wordfreq,
  title  = {Cleaned Word Frequency Lists (42 languages)},
  author = {VocabRadar},
  year   = {2026},
  url    = {https://huggingface.co/datasets/vocabradar/wordfreq}
}

About VocabRadar

This dataset is a VocabRadar project: it gives every word of vocabradar/wordfreq a vector, so the vocabulary radar can place a word in semantic space as soon as it meets it.

The VocabRadar browser extension marks up the words you do not know yet while you watch videos or browse the web: definitions in place, translation, bilingual subtitles and annotated subtitles. Whatever you looked up can go on to vocabradar.com, which turns it into related exercises and games so the words actually stick.

42 语 167 万词向量

为 vocabradar/wordfreq 清洗词表中的每一个词提供一个 384 维向量：42 种语言、1,672,738 个词。词表与向量矩阵逐行对齐——词在词表中的行号就是它在矩阵中的行号，也是它的词频排名。

向量由 hotchpotch/bekko-embedding-v1-a25m 生成——2490 万激活参数的多语言 ModernBERT（MIT），mean pooling、L2 归一化、384 维（Matryoshka 可截断到 256 / 128 / 64）。推理走 llama.cpp 官方 BF16 GGUF （--embedding --pooling mean --embd-normalize 2，Vulkan GPU 卸载），随后把每条归一化向量 按 127 的比例量化为 int8：全量约 612 MiB，余弦相似度误差约 0.001。

文件

WordEmbedding/
├── README.md                  # 本数据卡（中英双语）
├── meta.json                  # 模型、格式、逐语言统计
├── files.json                 # 每个数据文件的大小与 SHA-256
├── tools/
│   ├── build_dataset.py       # 推理（llama.cpp）+ 收尾（meta/files）
│   ├── gen_readme.py          # 重生成下方语言表
│   └── verify.py              # 复核大小、SHA-256、词表与矩阵对齐
└── data/
    ├── <lang>.words.txt       # UTF-8 词表，一行一词，按词频降序
    └── <lang>.int8.vector    # int8 向量，行优先，N × 384

每种语言一对文件（en、zh、ar……共 42 种）。

数据格式

以语言 xx 为例：

<xx>.words.txt —— 明文 UTF-8，一行一词，沿用清洗版 wordfreq 的词频降序；第 i 行（从 0 起）的词频排名为 i + 1。
<xx>.int8.vector —— 裸 int8、行优先、形状 N × 384、无文件头；第 i 行对应词表第 i 行的词。
N = 文件字节数 / 384。
反量化：v = int8 / 127.0。量化前每行已做 L2 归一化，因此反量化后近似单位长度。
余弦相似度：转成 float32 或 int32 后 dot(a, b) / 127²。不要直接对两个 int8 数组做 numpy.dot——384 维累加会溢出。

快速开始

import numpy as np

words = open("data/zh.words.txt", encoding="utf-8").read().splitlines()
vec = np.memmap("data/zh.int8.vector", dtype=np.int8, mode="r").reshape(-1, 384)
q = vec.astype(np.float32) / 127.0          # N × 384，近似单位长度

i = words.index("苹果")
sims = q @ q[i]
for j in np.argsort(-sims)[1:11]:
    print(f"{words[j]:10s} {sims[j]:.4f}")

同一套矩阵天然跨语言：苹果 会靠近 apple、pomme、Apfel 等——bekko 是多语言模型。

精度

在 1000 个英文词上实测 int8 量化：

指标	数值
float32 ↔ int8 余弦，最小 / 平均	0.99885 / 0.99902
Top-10 邻居重合率（200 次查询）	98.3%

误差远小于无关词之间的语义间距，这也是每个词只占 384 字节仍可用的原因。若需要更高保真度，可在 tools/build_dataset.py 中调整 SCALE 或改用更高精度重建。

meta.json → languages.<code>.zero_vectors 记录全零行数（分词后没有 token 的词）；逐语言数值见该字段。

模型与构建

项目	值
基座模型	`hotchpotch/bekko-embedding-v1-a25m`（MIT）
GGUF	`hotchpotch/bekko-embedding-v1-a25m-GGUF`，`BF16`，252,522,944 字节，SHA-256 `f85eda97…93d559`
架构	ModernBERT，2490 万激活参数
输出	384 维，mean pooling，L2 归一化
上下文	8192 token（单词远短于此）
运行时	llama.cpp `llama-server --embedding`（Vulkan GPU 卸载）

# 1) 把 GGUF 放到 work/models/（缺失时会自动从 hf-mirror 下载）
# 2) 若 llama.cpp 不在 BrowserExtention/backend/bin/llamacpp，用参数指定
python tools/build_dataset.py all
# 只跑部分语言 / 强制重跑
python tools/build_dataset.py embed --langs en zh --force
python tools/build_dataset.py finalize

build_dataset.py 会启动（或复用）本地 llama-server，每批 2048 词 POST 到 /v1/embeddings（base64 float32 回包），每批 fsync 落盘到 data/<lang>.int8.vector.part，进度记在 work/parts/<lang>.json。中断后从最后一批续跑，不重做整种语言；最后一批完成后才把 .part 改名为 <lang>.int8.vector。 Vulkan GPU 上约 700–1,200 词/秒，全量 42 语是几十分钟级。模型哈希、llama.cpp 版本与逐语言后端写入 meta.json。

两个任务可在不同端口上跑互不相交的语言集，例如一个 GPU 任务加一个 CPU 任务：

python tools/build_dataset.py embed --langs ta ru sk --port 18083 --gpu-layers 99
python tools/build_dataset.py embed --langs lt tr fi --port 18085 --gpu-layers 0 --threads 8

语言表

代码	语言	本地名	词数	向量体积 (MiB)
ar	Arabic	العربية	55,611	20.37
bg	Bulgarian	български	35,848	13.13
bn	Bengali	বাংলা	33,062	12.11
ca	Catalan	català	27,028	9.90
cs	Czech	čeština	51,744	18.95
da	Danish	dansk	29,321	10.74
de	German	Deutsch	38,989	14.28
el	Greek	Ελληνικά	43,191	15.82
en	English	English	28,223	10.34
es	Spanish	español	34,740	12.72
fa	Persian	فارسی	30,108	11.03
fi	Finnish	suomi	59,143	21.66
fil	Filipino	Filipino	30,098	11.02
fr	French	français	31,203	11.43
he	Hebrew	עברית	57,405	21.02
hi	Hindi	हिन्दी	24,031	8.80
hu	Hungarian	magyar	46,525	17.04
id	Indonesian	Bahasa Indonesia	30,967	11.34
is	Icelandic	íslenska	42,207	15.46
it	Italian	italiano	35,954	13.17
ja	Japanese	日本語	27,856	10.20
ko	Korean	한국어	26,807	9.82
lt	Lithuanian	lietuvių	63,973	23.43
lv	Latvian	latviešu	45,464	16.65
mk	Macedonian	македонски	32,925	12.06
ms	Malay	Bahasa Melayu	28,571	10.46
nb	Norwegian Bokmål	norsk bokmål	25,994	9.52
nl	Dutch	Nederlands	28,715	10.52
pl	Polish	polski	49,664	18.19
pt	Portuguese	português	33,123	12.13
ro	Romanian	română	43,279	15.85
ru	Russian	русский	59,604	21.83
sh	Serbo-Croatian	srpskohrvatski / српскохрватски	54,698	20.03
sk	Slovak	slovenčina	59,414	21.76
sl	Slovenian	slovenščina	53,882	19.73
sv	Swedish	svenska	30,515	11.17
ta	Tamil	தமிழ்	64,756	23.71
tr	Turkish	Türkçe	63,130	23.12
uk	Ukrainian	українська	46,286	16.95
ur	Urdu	اردو	22,442	8.22
vi	Vietnamese	Tiếng Việt	10,519	3.85
zh	Chinese	中文	35,723	13.08
合计	42 种语言	—	1,672,738	612.57

词数为该语言的向量条数，向量体积 为 .int8.vector 文件大小；合计行只对这两列求和。

许可与引用

向量模型为 MIT 许可；词表来自 vocabradar/wordfreq （元数据 MIT；上游 wordfreq 3.0.2）。使用本数据集请同时引用模型与词表：

@misc{bekko_embedding_v1_a25m,
  title  = {bekko-embedding-v1-a25m},
  author = {hotchpotch},
  year   = {2026},
  url    = {https://huggingface.co/hotchpotch/bekko-embedding-v1-a25m}
}
@misc{vocabradar_wordfreq,
  title  = {Cleaned Word Frequency Lists (42 languages)},
  author = {VocabRadar},
  year   = {2026},
  url    = {https://huggingface.co/datasets/vocabradar/wordfreq}
}

关于 VocabRadar

这项工作是 VocabRadar（词汇雷达）的工作：为 vocabradar/wordfreq 的每个词给出一个向量，让词汇雷达一见到某个词就能把它放进语义空间。

VocabRadar 浏览器扩展让你在看视频、刷网页时把还不认识的生词就地标注出来 —— 释义、翻译、双语字幕、注释字幕；查过的词还能送到 vocabradar.com，自动生成相关习题与游戏，把词真正记住。

Downloads last month: -

Total file size:

661 MB