fiqa_qwen3_embedding_0.6b

Single-vector dense embeddings of BEIR fiqa (beir/fiqa/test), encoded with Qwen/Qwen3-Embedding-0.6B at revision 97b0c614be4d77ee51c0cef4e5f07c00f9eb65b3. The model is trained with Matryoshka Representation Learning, so any leading prefix of a vector is itself an embedding: take v[:p] and L2-renormalize it. Exact ground truth is included at full dimension and at each prefix in {128, 256, 512, 640, 768, 896}.

Source data: ir_datasets beir/fiqa/test (ir_datasets 0.6.3), which downloads fiqa.zip (md5 17918ed23cd04fb15047f73e6c3bd9d9). BEIR also publishes this corpus on the Hub as BeIR/fiqa, whose card gives this dataset's license; the data here was loaded through ir_datasets, not from that repo. Document, query and qrel ids are the source's own ids, unchanged, and match the sibling multi-vector export robro612/fiqa_lateon row for row, so positional ground-truth indices are comparable across the two repos.

The files use the same layout as the multi-vector exports in this namespace: every document and every query is a "set" of exactly one 1024-d vector (doclens and query_lens are all 1), so multi-vector readers work unchanged and MaxSim is the dot product. Documents are stored in fp16 and queries in fp32, see Encoding.

Files

file	dtype	shape	contents
documents.npy	float16 (<f2)	[57,638, 1,024]	one vector per document, in doc_ids order (112.6 MiB)
doclens.npy	int32	[57,638]	vectors per document: all 1
doc_ids.npy	<U6	[57,638]	original document ids
queries.npy	float32 (<f4)	[648, 1, 1,024]	one vector per query (2.5 MiB)
query_lens.npy	int32	[648]	vectors per query: all 1
queries_ids.npy	<U5	[648]	original query ids
qrels.test.tsv	text	1,706 rows	TREC qrels, qid \t 0 \t docid \t relevance, no header
gt_top1000.tsv	text	648,000 rows	exact full-dimension top-1000, see below
gt_top100.tsv	text	64,800 rows	first 100 ranks of gt_top1000.tsv, same format
prefix_gt/gt_top100_dim{p}.tsv	text	64,800 rows each	exact top-100 by prefix cosine, p in {128, 256, 512, 640, 768, 896}

All positional indices (the gt_top*.tsv files, and the row order of every .npy file) refer to the order of doc_ids.npy and queries_ids.npy. Reordering either file invalidates the ground truth.

Statistics

documents	57,638
document vectors	57,638 (one per document)
queries	648
query vectors	648 (one per query)
queries with at least one qrel	648
qrels rows	1,706
embedding dimension	1024 (Matryoshka: any prefix)

Encoding

model	Qwen/Qwen3-Embedding-0.6B
model revision	97b0c614be4d77ee51c0cef4e5f07c00f9eb65b3
library	transformers 4.56.2 AutoModel (torch 2.5.1+cu121), SDPA attention
compute dtype	float16 for documents and queries (model weights loaded at this dtype)
document storage dtype	fp16 (normalized in fp32, then cast)
query storage dtype	fp32
pooling	last token: the hidden state at the final position, with left padding, as the model card specifies
normalization	L2 over the full 1024 dimensions, in fp32, before the storage cast. Prefixes are not normalized in the files; renormalize v[:p] yourself
document truncation	512 tokens including the appended end-of-text token (set for this export; the model allows 32,768). 2,328 of 57,638 documents (4%) were longer and were cut to it; the longest was 3,483 tokens
query truncation	512 tokens, prompt included; no query reached it (longest 53 tokens)
document input	the document text as the source gives it (no title field), no prompt; the tokenizer appends `<
query input	Instruct: Given a financial question, retrieve user replies that best answer the question\nQuery: + query text (the instruction format of the model card; the model's own MTEB instruction for FiQA2018)
document padding	none
query padding	none (query_lens is all 1)
token_ids	not provided: a pooled vector has no per-token ids

Ground truth

gt_top1000.tsv and gt_top100.tsv (full dimension)

Exact brute-force top-1000 per query over the full corpus, from the vectors in this repo. gt_top100.tsv holds the first 100 ranks per query of the same lists (the layout of the other exports in this namespace).

No header; tab-separated qidx docidx rank score:

• qidx: 0-based row into queries_ids.npy / queries.npy
• docidx: 0-based position into doc_ids.npy / doclens.npy
• rank: 1-based, descending score
• score: dot product of the query vector and the document vector (both unit-norm, so the cosine; this is also MaxSim with one vector each), computed in fp32 with the fp16 document vectors upcast to fp32. Printed to 6 decimals.

prefix_gt/gt_top100_dim{p}.tsv (Matryoshka prefixes)

Same format, exact top-100 per query, scored by the cosine of the first p dimensions: score = <q[:p], d[:p]> / (|q[:p]| |d[:p]|), fp32 with the fp16 documents upcast, for p in {128, 256, 512, 640, 768, 896}. The raw (unrenormalized) prefix dot product ranks differently and is not included.

Retrieval quality

Sanity check of the vectors, not a leaderboard number: gt_top1000.tsv (exact search over the full corpus) scored against qrels.test.tsv with ir_measures.

nDCG@10	MRR@10	Success@5	Recall@100	Recall@1000	MAP@1000
0.4695	0.5450	0.6821	0.8095	0.9483	0.4016

Per Matryoshka prefix, from prefix_gt/ (top-100, so no @1000 metrics). Acc@k is the overlap of the prefix's exact top-k with the full-dimension exact top-k, i.e. the best accuracy an index searching at that prefix can reach against full-dimension ground truth.

dim	Acc@10 vs full	Acc@100 vs full	nDCG@10	MRR@10	Success@5	Recall@100
128	0.5647	0.5722	0.4278	0.5132	0.6420	0.7520
256	0.6614	0.6763	0.4516	0.5283	0.6620	0.7932
512	0.7932	0.8021	0.4750	0.5491	0.6883	0.8078
640	0.8389	0.8477	0.4768	0.5587	0.6883	0.8095
768	0.8806	0.8872	0.4720	0.5492	0.6836	0.8085
896	0.9218	0.9283	0.4728	0.5516	0.6821	0.8140
1024 (full)	1.0000	1.0000	0.4695	0.5450	0.6821	0.8095

Loading

import numpy as np

documents = np.load("documents.npy", mmap_mode="r")      # [n_docs, 1024] float16
queries = np.load("queries.npy")[:, 0]                   # [n_queries, 1024] float32
doc_ids = np.load("doc_ids.npy")                         # [n_docs] str
query_ids = np.load("queries_ids.npy")                   # [n_queries] str

def prefix(x, p):                                        # Matryoshka: first p dims, renormalized
    x = np.asarray(x[..., :p], dtype=np.float32)
    return x / np.linalg.norm(x, axis=-1, keepdims=True)

scores = prefix(queries, 256) @ prefix(documents[:100_000], 256).T

The multi-vector loader of the other exports (doclens offsets, query_lens) also works as is.

Validation

Checks run by the exporter on the files exactly as written here (the shared multi-vector validator, plus the Matryoshka ground-truth checks):

• ✅ file set (+ prefix_gt/) — missing=[] extra=[]
• ✅ documents.npy dtype/shape — <f2 (57638, 1024)
• ✅ doclens.npy dtype/shape — <i4 (57638,)
• ✅ doc_ids.npy is a string array — <U6 (57638,)
• ✅ queries.npy dtype/shape — <f4 (648, 1, 1024)
• ✅ query_lens.npy dtype/shape — <i4 (648,)
• ✅ queries_ids.npy is a string array — <U5 (648,)
• ✅ sum(doclens) == n_tokens — 57638 vs 57638
• ✅ no empty documents — min doclen 1
• ✅ len(doc_ids) == len(doclens) == corpus size — 57638, 57638, 57638
• ✅ doc_ids unique
• ✅ query arrays aligned — 648, 648, 648
• ✅ doc and query dim agree — 1024 / 1024
• ✅ document vectors unit-norm (100k sample) — norm range [0.9999, 1.0001]
• ✅ query vectors unit-norm — norm range [1.000000, 1.000000]
• ✅ all vectors finite
• ✅ gt_top100.tsv has k rows per query — 64800 rows, k=100
• ✅ gt_top100.tsv rows grouped by qidx with ranks 1..k and descending scores
• ✅ gt_top100.tsv indices in range
• ✅ gt_top1000.tsv has k rows per query — 648000 rows, k=1000
• ✅ gt_top1000.tsv rows grouped by qidx with ranks 1..k and descending scores
• ✅ gt_top1000.tsv indices in range
• ✅ gt_top100.tsv is the first 100 ranks of gt_top1000.tsv
• ✅ one vector per document and per query
• ✅ prefix_gt/gt_top100_dim128.tsv: 100 rows per query, ranks 1..k, descending cosine <= 1, indices in range — 64800 rows
• ✅ prefix_gt/gt_top100_dim256.tsv: 100 rows per query, ranks 1..k, descending cosine <= 1, indices in range — 64800 rows
• ✅ prefix_gt/gt_top100_dim512.tsv: 100 rows per query, ranks 1..k, descending cosine <= 1, indices in range — 64800 rows
• ✅ prefix_gt/gt_top100_dim640.tsv: 100 rows per query, ranks 1..k, descending cosine <= 1, indices in range — 64800 rows
• ✅ prefix_gt/gt_top100_dim768.tsv: 100 rows per query, ranks 1..k, descending cosine <= 1, indices in range — 64800 rows
• ✅ prefix_gt/gt_top100_dim896.tsv: 100 rows per query, ranks 1..k, descending cosine <= 1, indices in range — 64800 rows
• ✅ gt_top1000.tsv scores <= 1 (unit vectors) — max 0.869975

Provenance

exported	2026-11-06
encode hardware	Tesla V100-SXM2-32GB-LS (Slurm jobs 1198827)
ground-truth hardware	Tesla V100S-PCIE-32GB
code	encoder scripts/encode.py, exporter scripts/export_hf.py in the MRL kannolo/vectorium experiments