lightonai / Reason-ModernColBERT

Reason-ModernColBERT

Reason-ModernColBERT is a late interaction model trained on the reasonir-hq dataset. It achieves extremely competitive performance on the BRIGHT benchmark aimed at evaluating reasoning-intensive retrieval performance, outperforming all existing models up to 7B (more than 45 times its size) and even surprisingly improving performance of ReasonIR-8B (a 8B model trained on the same data) by more than 2.5 NDCG@10 on average on Stack Exchange splits. We attribute such strong results to late-interaction, see evaluation section .

License

Unfortunately, since the ReasonIR data has been released under a cc-by-nc-4.0 license, we cannot release this model under an Apache 2.0 license. However, the authors of ReasonIR released code to generate the data . Anyone willing to reproduce the data could then easily reproduce this model under an Apache 2.0 license by running a fine-tuning lasting lower than 2 hours using this boilerplate .

PyLate model based on lightonai/GTE-ModernColBERT-v1

This is a PyLate model finetuned from lightonai/GTE-ModernColBERT-v1 on the reasonir-hq dataset. It maps sentences & paragraphs to sequences of 128-dimensional dense vectors and can be used for semantic textual similarity using the MaxSim operator.

Model Details

Model Description

• Model Type: PyLate model
• Base model: lightonai/GTE-ModernColBERT-v1
• Document Length: 8192 tokens
• Query Length: 128 tokens
• Output Dimensionality: 128 tokens
• Similarity Function: MaxSim
• Training Dataset:
  • reasonir-hq
• Language: en

Model Sources

• Documentation: PyLate Documentation
• Repository: PyLate on GitHub
• Hugging Face: PyLate models on Hugging Face

Full Model Architecture

ColBERT(
  (0): Transformer({'max_seq_length': 127, 'do_lower_case': False}) with Transformer model: ModernBertModel 
  (1): Dense({'in_features': 768, 'out_features': 128, 'bias': False, 'activation_function': 'torch.nn.modules.linear.Identity'})
)

Usage

First install the PyLate library:

pip install -U pylate

Retrieval

PyLate provides a streamlined interface to index and retrieve documents using ColBERT models. The index leverages the Voyager HNSW index to efficiently handle document embeddings and enable fast retrieval.

Indexing documents

First, load the ColBERT model and initialize the Voyager index, then encode and index your documents:

from pylate import indexes, models, retrieve

# Step 1: Load the ColBERT model
model = models.ColBERT(
    model_name_or_path=pylate_model_id,
)

# Step 2: Initialize the Voyager index
index = indexes.Voyager(
    index_folder="pylate-index",
    index_name="index",
    override=True,  # This overwrites the existing index if any
)

# Step 3: Encode the documents
documents_ids = ["1", "2", "3"]
documents = ["document 1 text", "document 2 text", "document 3 text"]

documents_embeddings = model.encode(
    documents,
    batch_size=32,
    is_query=False,  # Ensure that it is set to False to indicate that these are documents, not queries
    show_progress_bar=True,
)

# Step 4: Add document embeddings to the index by providing embeddings and corresponding ids
index.add_documents(
    documents_ids=documents_ids,
    documents_embeddings=documents_embeddings,
)

Note that you do not have to recreate the index and encode the documents every time. Once you have created an index and added the documents, you can re-use the index later by loading it:

# To load an index, simply instantiate it with the correct folder/name and without overriding it
index = indexes.Voyager(
    index_folder="pylate-index",
    index_name="index",
)

Retrieving top-k documents for queries

Once the documents are indexed, you can retrieve the top-k most relevant documents for a given set of queries. To do so, initialize the ColBERT retriever with the index you want to search in, encode the queries and then retrieve the top-k documents to get the top matches ids and relevance scores:

# Step 1: Initialize the ColBERT retriever
retriever = retrieve.ColBERT(index=index)

# Step 2: Encode the queries
queries_embeddings = model.encode(
    ["query for document 3", "query for document 1"],
    batch_size=32,
    is_query=True,  #  # Ensure that it is set to False to indicate that these are queries
    show_progress_bar=True,
)

# Step 3: Retrieve top-k documents
scores = retriever.retrieve(
    queries_embeddings=queries_embeddings,
    k=10,  # Retrieve the top 10 matches for each query
)

Reranking

If you only want to use the ColBERT model to perform reranking on top of your first-stage retrieval pipeline without building an index, you can simply use rank function and pass the queries and documents to rerank:

from pylate import rank, models

queries = [
    "query A",
    "query B",
]

documents = [
    ["document A", "document B"],
    ["document 1", "document C", "document B"],
]

documents_ids = [
    [1, 2],
    [1, 3, 2],
]

model = models.ColBERT(
    model_name_or_path=pylate_model_id,
)

queries_embeddings = model.encode(
    queries,
    is_query=True,
)

documents_embeddings = model.encode(
    documents,
    is_query=False,
)

reranked_documents = rank.rerank(
    documents_ids=documents_ids,
    queries_embeddings=queries_embeddings,
    documents_embeddings=documents_embeddings,
)

Evaluation

BRIGHT Benchmark

The BRIGHT benchmark is aimed at evaluating reasoning-intensive retrieval performance. Reason-ModernColBERT outperforms all existing models up to 7B (more than 45 times its size) and even surprisingly improving performance of ReasonIR-8B (a 8B model trained on the same data) by more than 2.5 NDCG@10 on average on Stack Exchange splits. We attribute such strong results to late-interaction compared to usual dense (single vector) retrieval performed by other models as highlighted in the next section.

Comparison with a dense model

A fair claim would be that the performance of Reason-ModernColBERT are mostly due to the ReasonIR data . Although the differences between ReasonIR-8B and Reason-ModernColBERT already hint that it is most likely more than just that, we conducted a small experiment by training a dense (single vector) model in the same setup using Sentence Transformers as a multi-vector one trained using PyLate. This experiment highlights a very large gap in performance. Obviously, more rigourous experiments are required to draw conclusion (e.g, both models could have been further tuned and the training could have been enhanced (e.g, we did not gather negatives from other GPUs in these experiments because ST do not supports it for now)) but the gap seems really big and it does correlate pretty well with Reason-ModernColBERT being competitive with ReasonIR-8B while being more than 50 times smaller.

GPT4 reasoning trace

Although those models are able to do some reasoning-intensive matching, it has been shown that they greatly benefits from using the reasoning trace/query reformulation from a LLM such as GPT4. Here is the results of Reason-ModernColBERT on this setup:

As highlighted by these results, Reason-ModernColBERT benefits greatly from using those traces (+7.66 NDCG@10 in average) even more than ReasonIR-8B (+5.58). It thus reaches top-1 by closing the gap and outperforms it on this setup, as well as outperforming methods based on reranking with 7B models. However, it should be noted that these experiments also highlighted that Reason-ModernColBERT does not scale very well to very large queries (while ColBERT models are known to generalize very well to large documents), most probably due to the assymetric nature of the MaxSim operator. This prevent the model from leveraging the full query rewriting and reasoning trace from the LLM. Training the model on longer and more diverse lengths of queries, such as in the VL split of the ReasonIR data is a promising avenue to better leverage these extensive queries/reasoning trace.

In an effort of transparency, please note that, contrary to the main results that have been evaluated with mostly the same query length (except Pony), those results have been obtained by sweeping over query lengths, here are the query lengths used for each split:

Training Details

Training Dataset

reasonir-hq

• Dataset: train at 0275f82
• Size: 100,521 training samples
• Columns: query , pos , and neg
• Approximate statistics based on the first 1000 samples:

  	query	pos	neg
  type	string	string	string
  details	min: 38 tokens mean: 97.84 tokens max: 128 tokens	min: 85 tokens mean: 127.63 tokens max: 128 tokens	min: 81 tokens mean: 127.77 tokens max: 128 tokens

• Samples:

  query	pos	neg
  Given this reasoning-intensive query, find relevant documents that could help answer the question. A researcher is analyzing a sound signal represented by the equation f(t) = 2sin(3πt) + sin(5πt) + 0.5sin(7πt). Using the Fourier transform, what are the frequencies, amplitudes, and phases of the individual sinusoidal components in the signal?	A sound signal is given by the equation f(t) = sin(2πt) + sin(4πt) + sin(6πt) where t is time in seconds. Use Fourier transform to find the frequencies, amplitudes, and phases of the individual sinusoidal components in the signal. To find the frequencies, amplitudes, and phases of the individual sinusoidal components in the signal f(t) = sin(2πt) + sin(4πt) + sin(6πt), we can use the Fourier transform. The Fourier transform of a continuous function f(t) is given by: F(ω) = ∫[f(t) * e^(-jωt)] dt where F(ω) is the Fourier transform of f(t), ω is the angular frequency, and j is the imaginary unit (j^2 = -1). In this case, f(t) is already given as a sum of sinusoidal functions, so we can directly identify the frequencies, amplitudes, and phases of the individual components. 1. First component: sin(2πt) - Frequency: The angular frequency is 2π, so the frequency is ω/(2π) = 1 Hz. - Amplitude: The coefficient of the sine function is 1, so the amplitude is 1. - Phase: There is no phase shi...	The Fourier transform is widely used in various fields, including engineering, physics, and data analysis. It is a powerful tool for decomposing a signal into its constituent frequencies. In music, for example, the Fourier transform can be used to analyze the frequency components of a sound wave. By applying the Fourier transform to a sound signal, one can identify the different frequencies present in the signal, as well as their relative amplitudes. This information can be useful in a variety of applications, such as sound filtering and audio processing. The Fourier transform can also be used to analyze images and other types of data. In image processing, the Fourier transform can be used to filter out noise and other unwanted features from an image. It can also be used to compress images by representing them in the frequency domain. In addition to its many practical applications, the Fourier transform also has a number of interesting theoretical properties. For example, it has been ...
  Given this reasoning-intensive query, find relevant documents that could help answer the question. A manufacturer is designing a cone-shaped container with a fixed volume of 200π cubic centimeters. The container's height is 12 centimeters, and the radius of the base is unknown. If the manufacturer wants to minimize the surface area of the container while maintaining its volume, what should be the radius of the base?	A right circular cone has a radius of 6cm and a slant height of 10cm. Determine the surface area of the cone. To find the surface area of a right circular cone, we need to calculate the area of the base and the lateral surface area, and then add them together. The base of the cone is a circle with radius r = 6 cm. The area of the base (A_base) can be found using the formula for the area of a circle: A_base = πr^2 A_base = π(6 cm)^2 A_base = 36π cm^2 The lateral surface area (A_lateral) can be found using the formula for the lateral surface area of a cone: A_lateral = πrs, where r is the radius and s is the slant height. Given that the slant height s = 10 cm, we can calculate the lateral surface area: A_lateral = π(6 cm)(10 cm) A_lateral = 60π cm^2 Now, we can find the total surface area (A_total) by adding the base area and the lateral surface area: A_total = A_base + A_lateral A_total = 36π cm^2 + 60π cm^2 A_total = 96π cm^2 The surface area of the cone is 96π cm^2.	Torus-Shaped Containers in Chemical Engineering - New Designs and ApplicationsTorus-shaped containers are commonly used in chemical engineering for storing and transporting fluids. These containers have a distinctive doughnut shape, with a central hole and a circular cross-section. In this article, we will explore the design and applications of torus-shaped containers in chemical engineering.One of the main advantages of torus-shaped containers is their high volume-to-surface-area ratio. This makes them ideal for storing large quantities of fluids while minimizing the amount of material needed for construction. Additionally, the curved shape of the container provides added strength and stability, making it less prone to rupture or leakage.The design of torus-shaped containers typically involves the use of computer-aided design (CAD) software to create detailed models of the container's geometry. Engineers can then use these models to simulate various scenarios, such as fluid flow and ...
  Given this reasoning-intensive query, find relevant documents that could help answer the question. On the xy-coordinate plane, points A and B are given as A(2, 4) and B(8, -3). Determine the coordinates of the point on line segment AB that is three times as far from A as it is from B.	On the xy co-ordinate plane, point C is (5,-2) and point D is (-1,1.5). The point on line segment CD that is twice as far from C as from D is: Answer Choices: (A) (1,-1) (B) (1,1) (C) (2,0.25) (D) (3,0.5) (E) (3,1) Let's think about the multi-choice question step by step. We want the point on the line that is twice as far from C as it is from D. We can examine the x and y coordinates separately since they are independent. *It should be noted that there are two solutions to this problem, one point between C and D, and another point with D in the middle of C and the point. We can quickly look at the answer choices and see that all the points are between C and D, therefore we can search for that point using the following method: Taking the x-coordinate first, the distance between C and D is	(x-coordinate ofC - (x-coordinate ofD

• Loss: pylate.losses.cached_contrastive.CachedContrastive

Training Hyperparameters

Non-Default Hyperparameters

• per_device_train_batch_size : 256
• per_device_eval_batch_size : 256
• learning_rate : 1e-05
• bf16 : True
• dataloader_num_workers : 8

All Hyperparameters

Training Logs

Framework Versions

• Python: 3.11.10
• Sentence Transformers: 4.0.2
• PyLate: 1.1.7
• Transformers: 4.48.2
• PyTorch: 2.5.1+cu124
• Accelerate: 1.1.1
• Datasets: 2.21.0
• Tokenizers: 0.21.0

Citation

BibTeX

Reason-ModernColBERT

@misc{Reason-ModernColBERT,
title={Reason-ModernColBERT},
author={Chaffin, Antoine},
url={https://huggingface.co/lightonai/Reason-ModernColBERT},
year={2025}
}

GTE-ModernColBERT

@misc{GTE-ModernColBERT,
title={GTE-ModernColBERT},
author={Chaffin, Antoine},
url={https://huggingface.co/lightonai/GTE-ModernColBERT-v1},
year={2025}
}

Sentence Transformers

@inproceedings{reimers-2019-sentence-bert,
    title = "Sentence-BERT: Sentence Embeddings using Siamese BERT-Networks",
    author = "Reimers, Nils and Gurevych, Iryna",
    booktitle = "Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing",
    month = "11",
    year = "2019",
    publisher = "Association for Computational Linguistics",
    url = "https://arxiv.org/abs/1908.10084"
}

PyLate

@misc{PyLate,
title={PyLate: Flexible Training and Retrieval for Late Interaction Models},
author={Chaffin, Antoine and Sourty, Raphaël},
url={https://github.com/lightonai/pylate},
year={2024}
}

CachedContrastive

@misc{gao2021scaling,
    title={Scaling Deep Contrastive Learning Batch Size under Memory Limited Setup},
    author={Luyu Gao and Yunyi Zhang and Jiawei Han and Jamie Callan},
    year={2021},
    eprint={2101.06983},
    archivePrefix={arXiv},
    primaryClass={cs.LG}
}