File size: 7,694 Bytes
99a2fd6 579b2ff 99a2fd6 43e45a1 99a2fd6 43e45a1 99a2fd6 43e45a1 99a2fd6 579b2ff 99a2fd6 579b2ff 43e45a1 99a2fd6 579b2ff 43e45a1 99a2fd6 579b2ff 43e45a1 579b2ff 99a2fd6 579b2ff 99a2fd6 579b2ff 99a2fd6 579b2ff | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 | ---
pretty_name: vidore3_finance_neomme_260m_li
license: cc-by-4.0
tags:
- multi-vector
- late-interaction
- colbert
- embeddings
- retrieval
- image
---
# vidore3_finance_neomme_260m_li
Multi-vector (late-interaction) embeddings of **ViDoRe finance** (`vidore/finance`), encoded with
**[Hcompany/NeoMME-260M-Retriever-ST-late](https://huggingface.co/Hcompany/NeoMME-260M-Retriever-ST-late)** at revision `023be2a8ab9d797f5aa76f5bf8b5dde78d819659`.
**Source data:** Hugging Face dataset [`vidore/vidore_v3_finance_en`](https://huggingface.co/datasets/vidore/vidore_v3_finance_en) at revision `7f432c176d82e27546501ad8064a713ac3071809`, configs `corpus` / `queries` / `qrels`, split `test`, loaded with `datasets`. Document, query and qrel ids are the source's own ids,
unchanged.
Every document is one variable-length set of 128-d vectors; every query is one variable-length
set of 128-d vectors. Documents and queries are stored at different precisions (fp16 and fp32
respectively), see [Encoding](#encoding).
## Files
| file | dtype | shape | contents |
|---|---|---|---|
| `documents.npy` | float16 (`<f2`) | `[9,608,572, 128]` | every document vector, concatenated document by document (2,345.8 MiB) |
| `doclens.npy` | int32 | `[2,942]` | vectors per document; `cumsum` gives offsets |
| `doc_ids.npy` | `<U4` | `[2,942]` | original document ids |
| `queries.npy` | float32 (`<f4`) | `[1,854, 94, 128]` | query vectors, zero-padded at the end (85.1 MiB) |
| `query_lens.npy` | int32 | `[1,854]` | true vectors per query, before padding |
| `queries_ids.npy` | `<U4` | `[1,854]` | original query ids |
| `qrels.test.tsv` | text | 8,766 rows | TREC qrels, `qid \t 0 \t docid \t relevance`, no header |
| `gt_top1000.tsv` | text | 1,854,000 rows | exact MaxSim top-1000, see below |
| `gt_top100.tsv` | text | 185,400 rows | first 100 ranks of `gt_top1000.tsv`, same format |
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 | 2,942 |
| document vectors | 9,608,572 |
| vectors per document (min / median / mean / max) | 3266 / 3266 / 3266.0 / 3266 |
| queries | 1,854 |
| vectors per query (min / median / mean / max) | 18 / 36 / 37.8 / 94 |
| queries with at least one qrel | 1,854 |
| qrels rows | 8,766 |
| embedding dimension | 128 |
## Encoding
| | |
|---|---|
| model | [Hcompany/NeoMME-260M-Retriever-ST-late](https://huggingface.co/Hcompany/NeoMME-260M-Retriever-ST-late) |
| model revision | `023be2a8ab9d797f5aa76f5bf8b5dde78d819659` |
| library | sentence-transformers 6.0.1 `MultiVectorEncoder` (transformers 5.17.0, torch 2.11.0+cu126) |
| document compute dtype | float16 (model weights loaded at this dtype for the document pass) |
| document storage dtype | fp16 |
| query compute dtype | float32 (model weights loaded at this dtype for the query pass) |
| query storage dtype | fp32 |
| normalization | L2, by the model's own `Normalize` module, before the storage cast |
| document truncation | none (`document_length` unset), so the model limit of 16,384 tokens applies; longest document here 3,266 vectors |
| query truncation | none (`query_length` unset) |
| document skiplist | none (empty `skiplist_words`): every document token is kept, so doclens is the real token count |
| document input | page image, one vector per image patch plus layout tokens; processor default resizing |
| query input | query text, stripped of surrounding whitespace, formatted by the model's own query prompt/template |
| query vectors | every vector the model emits for the query is kept, including any query-expansion tokens its template adds; `query_lens` counts them all |
| document padding | none: `documents.npy` holds real vectors only, `sum(doclens) == n_tokens` |
| query padding | rows at or beyond `query_lens[i]` in `queries.npy[i]` are exactly zero |
| token_ids | not provided: image-patch vectors have no vocabulary ids (only placeholder ids) |
## Ground truth: `gt_top1000.tsv` and `gt_top100.tsv`
Exact brute-force MaxSim 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 original layout of these exports).
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`: `sum over the query's query_lens[qidx] vectors of max over the document's vectors of the
dot product`, computed in fp32 with the fp16 document vectors upcast to fp32. Expansion vectors
are included in the sum. Printed to 6 decimals.
## Retrieval quality
Sanity check of the vectors, not a leaderboard number: `gt_top1000.tsv` (exact MaxSim 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.5643 | 0.6788 | 0.8328 | 0.8669 | 0.9940 | 0.4904 |
## Loading
```python
import numpy as np
documents = np.load("documents.npy", mmap_mode="r") # [n_tokens, 128] float16
doclens = np.load("doclens.npy") # [n_docs] int32
offsets = np.concatenate([[0], np.cumsum(doclens)])
doc_ids = np.load("doc_ids.npy") # [n_docs] str
def document(i):
return documents[offsets[i]:offsets[i + 1]] # [doclens[i], 128]
queries = np.load("queries.npy") # [n_queries, 94, 128] float32
query_lens = np.load("query_lens.npy") # [n_queries] int32
query_ids = np.load("queries_ids.npy") # [n_queries] str
def query(j):
return queries[j, :query_lens[j]] # [query_lens[j], 128]
def maxsim(q, d):
return (q @ d.astype(np.float32).T).max(axis=1).sum()
```
## Validation
Checks run by the exporter on the files exactly as written here:
- ✅ file set — missing=[] extra=[]
- ✅ documents.npy dtype/shape — <f2 (9608572, 128)
- ✅ doclens.npy dtype/shape — <i4 (2942,)
- ✅ doc_ids.npy is a string array — <U4 (2942,)
- ✅ queries.npy dtype/shape — <f4 (1854, 94, 128)
- ✅ query_lens.npy dtype/shape — <i4 (1854,)
- ✅ queries_ids.npy is a string array — <U4 (1854,)
- ✅ sum(doclens) == n_tokens — 9608572 vs 9608572
- ✅ no empty documents — min doclen 3266
- ✅ len(doc_ids) == len(doclens) == corpus size — 2942, 2942, 2942
- ✅ doc_ids unique
- ✅ query arrays aligned — 1854, 1854, 1854
- ✅ doc and query dim agree — 128 / 128
- ✅ document vectors unit-norm (100k sample) — norm range [0.9995, 1.0006]
- ✅ query vectors unit-norm — norm range [1.000000, 1.000000]
- ✅ all vectors finite
- ✅ gt_top100.tsv has k rows per query — 185400 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 — 1854000 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
## Provenance
| | |
|---|---|
| exported | 2026-09-23 |
| hardware | Tesla V100S-PCIE-32GB |
| revised | 2026-09-29: ground truth extended to top-1000 (`gt_top1000.tsv`, exact MaxSim over this repo's vectors on Tesla V100S-PCIE-32GB); `gt_top100.tsv` rewritten as its first 100 ranks: 24,173 rows differ from the previous file, 40 with a different document at that rank, scores moving by at most 0.000008 |
|