---
pretty_name: lotte_pooled_dev_search_mlateon
license: apache-2.0
tags:
- multi-vector
- late-interaction
- colbert
- embeddings
- retrieval
- text
---

# lotte_pooled_dev_search_mlateon

Multi-vector (late-interaction) embeddings of **LoTTE pooled/dev/search** (`lotte/pooled/dev/search`), encoded with
**[lightonai/mLateOn](https://huggingface.co/lightonai/mLateOn)** at revision `edd378f99593c0ac8a15518b97ad89786b02685e`.

**Source data:** [ir_datasets](https://ir-datasets.com/lotte.html#lotte/pooled/dev/search) `lotte/pooled/dev/search` (ir_datasets 0.6.3), which downloads [lotte.tar.gz](https://downloads.cs.stanford.edu/nlp/data/colbert/colbertv2/lotte.tar.gz) (md5 `3b2e88b1d66933627462950b4c3f5d0f`). The ColBERTv2 authors also publish LoTTE on the Hub as [`colbertv2/lotte`](https://huggingface.co/datasets/colbertv2/lotte), 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.

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`) | `[530,764,096, 128]` | every document vector, concatenated document by document (129,581.1 MiB) |
| `doclens.npy` | int32 | `[2,428,854]` | vectors per document; `cumsum` gives offsets |
| `token_ids.npy` | uint32 | `[530,764,096]` | tokenizer id of each `documents.npy` row, 1:1 |
| `doc_ids.npy` | `<U7` | `[2,428,854]` | original document ids |
| `queries.npy` | float32 (`<f4`) | `[2,931, 28, 128]` | query vectors, zero-padded at the end (40.1 MiB) |
| `query_lens.npy` | int32 | `[2,931]` | true vectors per query, before padding |
| `queries_ids.npy` | `<U4` | `[2,931]` | original query ids |
| `qrels.test.tsv` | text | 8,573 rows | TREC qrels, `qid \t 0 \t docid \t relevance`, no header |
| `gt_top1000.tsv` | text | 2,931,000 rows | exact MaxSim top-1000, see below |
| `gt_top100.tsv` | text | 293,100 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,428,854 |
| document vectors | 530,764,096 |
| vectors per document (min / median / mean / max) | 4 / 145 / 218.5 / 8192 |
| queries | 2,931 |
| vectors per query (min / median / mean / max) | 9 / 11 / 11.9 / 28 |
| queries with at least one qrel | 2,931 |
| qrels rows | 8,573 |
| embedding dimension | 128 |

## Encoding

| | |
|---|---|
| model | [lightonai/mLateOn](https://huggingface.co/lightonai/mLateOn) |
| model revision | `edd378f99593c0ac8a15518b97ad89786b02685e` |
| library | sentence-transformers 6.1.0 `MultiVectorEncoder` (transformers 5.17.0, torch 2.13.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 | 8,192 tokens (the checkpoint's `document_length`). 79 of 2,428,854 documents (0.0033%) were longer and were cut to it; longest here 8,192 vectors |
| query truncation | 8,192 tokens (the checkpoint's `query_length`) |
| document skiplist | none (empty `skiplist_words`): every document token is kept, so doclens is the real token count |
| document input | `title + "\n\n" + text` when the corpus has a title, else `text`; stripped |
| 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 | tokenizer id of each kept document token (no skiplist, so every token), aligned 1:1 with `documents.npy` |

## 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.5706 | 0.6531 | 0.7919 | 0.8369 | 0.9363 | 0.5012 |

## 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, 28, 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 (530764096, 128)
- ✅ doclens.npy dtype/shape — <i4 (2428854,)
- ✅ doc_ids.npy is a string array — <U7 (2428854,)
- ✅ queries.npy dtype/shape — <f4 (2931, 28, 128)
- ✅ query_lens.npy dtype/shape — <i4 (2931,)
- ✅ queries_ids.npy is a string array — <U4 (2931,)
- ✅ sum(doclens) == n_tokens — 530764096 vs 530764096
- ✅ no empty documents — min doclen 4
- ✅ len(doc_ids) == len(doclens) == corpus size — 2428854, 2428854, 2428854
- ✅ doc_ids unique
- ✅ query arrays aligned — 2931, 2931, 2931
- ✅ doc and query dim agree — 128 / 128
- ✅ token_ids.npy dtype/shape — <u4 (530764096,)
- ✅ document vectors unit-norm (100k sample) — norm range [0.9994, 1.0006]
- ✅ query vectors unit-norm — norm range [1.000000, 1.000000]
- ✅ all vectors finite
- ✅ gt_top100.tsv has k rows per query — 293100 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 — 2931000 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-26 |
| hardware | Tesla V100S-PCIE-32GB |
| revised | 2026-09-30: 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: 462 rows differ from the previous file, 427 with a different document at that rank, scores moving by at most 0.000002 (5 query-document pairs left the top 100) |