Upload 9 files

scripts/README.md

@@ -0,0 +1,79 @@
+# TREC RAG baselines using arctic-l and arctic-m-v1.5
+
+First, download the data including documents, queries, qrels. 
+
+
+## Generate The doc and query embeddings
+
+```sh
+bash get_data.sh
+```
+
+Next, go ahead and convert the qrels format into json using the script below. 
+
+```sh
+python convert_qrels_to_json.py
+```
+
+After that, go ahead and generate the query embeddings using the command below. 
+
+```sh
+python generate_query_embeddings.py
+```
+
+After that, go ahead and generate embeddings for each shard. This will take ~ 20m per shard on a single H100. Feel free to parallelize. Make sure you have at least 600 gbs free.
+
+```sh
+python generate_doc_embeddings.py
+```
+
+
+## Retrieval Runs
+Once you have query and doc embeddings go ahead and retrieve. Given the size of the vectors we do this in shards. First we retrieve the top_n from each shard for each queryset on each shard. Feel free to parrelize. 
+
+```sh
+python retrieve_from_shard.py <path to embeddings> <query_embedding_prefix>  <shard> <num_retrieved> <use_faiss>
+```
+Alternatively, you can just run retrieve.sh in the background. 
+
+```sh
+python merge_retrieved_shard.py <shard_retrieved_results> <output_filename> <top_n_docs> <qrel json> <metric to get per_query breakdown>
+```
+## Retrieval Scores
+
+
+### NDCG@10
+| NDCG @10           |        |                |          |               |               |               |                           |
+|--------------------|--------|----------------|----------|---------------|---------------|---------------|---------------------------|
+| Dataset            | BM25   | GTE-Large-v1.5 | Arctic-L | Arctic-M-V1.5 | Arctic-M-V1.5 | Arctic-M-V1.5 | Cohere Embed3 - Trunc 128 |
+| Dim                | N/A    |           1024 |     1024 |           768 |           256 |           128 |                       128 |
+| Deep Learning 2021 | 0.5778 |   0.71928             |  0.70682 |        0.6936 |       0.69392 |       0.60578 |                    0.6962 |
+| Deep Learning 2022 | 0.3576 |    0.53576            |   0.5444 |       0.55199 |       0.55608 |       0.47348 |                    0.5396 |
+| Deep Learning 2023 | 0.3356 |      0.46423           |  0.47372 |       0.46963 |       0.45196 |       0.32789 |                    0.4473 |
+| msmarcov2-dev      | N/A    |  0.3538              |  0.35844 |         0.346 |       0.34074 |       0.28499 | N/A                       |
+| msmarcov2-dev2     | N/A    |   0.34698             |  0.35821 |       0.34518 |       0.34339 |       0.29606 | N/A                       |
+| Raggy Queries      | 0.4227 |   0.56782             |  0.57759 |       0.57439 |       0.56686 |       0.47555 | N/A                       |
+
+### Recall @100
+| Recall@100         |        |                |          |               |               |               |                           |
+|--------------------|--------|----------------|----------|---------------|---------------|---------------|---------------------------|
+| Dataset            | BM25   | GTE-Large-v1.5 | Arctic-L | Arctic-M-V1.5 | Arctic-M-V1.5 | Arctic-M-V1.5 | Cohere Embed3 - Trunc 128 |
+| Dim                | N/A    |           1024 |     1024 |           768 |           256 |           128 |                       128 |
+| Deep Learning 2021 | 0.3811 |  0.4156              |  0.41361 |          0.43 |       0.42245 |        0.3488 |                    0.3914 |
+| Deep Learning 2022 |  0.233 |  0.31173              |  0.31351 |       0.32125 |        0.3165 |       0.26714 |                    0.3019 |
+| Deep Learning 2023 | 0.3049 |   0.35236             |  0.34793 |       0.37622 |       0.36089 |       0.28314 |                    0.3438 |
+| msmarcov2-dev      | 0.6683 |   0.85135             |  0.85131 |       0.85435 |       0.84985 |       0.76201 | N/A                       |
+| msmarcov2-dev2     | 0.6771 |  0.84333              |  0.84767 |        0.8576 |        0.8526 |       0.78987 | N/A                       |
+| Raggy Queries      | 0.2807 |    0.35125            |  0.36228 |       0.36915 |       0.36149 |       0.30272 | N/A                       |
+### Recall @1000
+
+| Recall@1000        |        |                |          |               |               |               |                           |
+|--------------------|--------|----------------|----------|---------------|---------------|---------------|---------------------------|
+| Dataset            | BM25   | GTE-Large-v1.5 | Arctic-L | Arctic-M-V1.5 | Arctic-M-V1.5 | Arctic-M-V1.5 | Cohere Embed3 - Trunc 128 |
+| Dim                | N/A    |           1024 |     1024 |           768 |           256 |           128 |                       128 |
+| Deep Learning 2021 | 0.7115 |   0.73185             |   0.7193 |       0.74895 |       0.73511 |       0.63253 |                    0.7188 |
+| Deep Learning 2022 |  0.479 |    0.55174             |  0.54566 |       0.55413 |       0.54499 |       0.47823 |                    0.5558 |
+| Deep Learning 2023 | 0.5852 |      0.6167           |  0.59577 |       0.62262 |       0.61199 |       0.49188 |                    0.6025 |
+| msmarcov2-dev      | 0.8528 |   0.93549              |  0.93966 |       0.94156 |       0.94014 |       0.87705 | N/A                       |
+| msmarcov2-dev2     | 0.8577 |   0.93997              |  0.93947 |       0.94277 |       0.94047 |       0.91683 | N/A                       |
+| Raggy Queries      | 0.5745 |   0.63515             |  0.63092 |       0.64527 |       0.63826 |       0.55002 | N/A                       |

scripts/convert_qrels_to_json.py

@@ -0,0 +1,21 @@
+import json
+
+qrel_filenames = [
+    "qrels.dl21-doc-msmarco-v2.1.txt",
+    "qrels.msmarco-v2.1-doc.dev.txt",
+    "qrels.dl22-doc-msmarco-v2.1.txt",
+    "qrels.msmarco-v2.1-doc.dev2.txt",
+    "qrels.dl23-doc-msmarco-v2.1.txt",
+    "qrels.rag24.raggy-dev.txt",
+]
+for filename in qrel_filenames:
+    short_filename = filename.split("qrels.")[1][:-4]
+    qrels: dict = {}
+    with open(filename, "r") as f:
+        for line in f:
+            qid, _, doc_id, label = line.strip().split()
+            if qid not in qrels:
+                qrels[qid] = {}
+            qrels[qid][doc_id] = int(label)
+    with open(f"{short_filename}.json", "w") as w:
+        w.write(json.dumps(qrels))

scripts/generate_doc_embeddings.py

@@ -0,0 +1,79 @@
+import json
+import os
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+import torch
+from tqdm import tqdm
+from transformers import AutoModel, AutoTokenizer
+
+file_name_prefix = "msmarco_v2.1_doc_segmented_"
+path = "/home/mltraining/msmarco_v2.1_doc_segmented/"
+model_names = [
+    "Snowflake/snowflake-arctic-embed-l",
+    "Snowflake/snowflake-arctic-embed-m-v1.5",
+]
+for model_name in model_names:
+    print(f"Running doc embeddings using {model_name}")
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    model = AutoModel.from_pretrained(
+        model_name,
+        add_pooling_layer=False,
+    )
+    model.eval()
+    device = "cuda"
+    model = model.to(device)
+    dir_path = f"{path}{model_name.split('/')[1]}/"
+    if not os.path.exists(dir_path):
+        os.makedirs(dir_path)
+    for i in range(0, 59):
+        try:
+            filename = f"{path}{file_name_prefix}{i:02}.json"
+            filename_out = f"{dir_path}{i:02}.parquet"
+            print(f"Starting doc embeddings on {filename}")
+            data = []
+            ids = []
+            with open(filename, "r") as f:
+                for line in tqdm(f, desc="Processing JSONL file"):
+                    j = json.loads(line)
+                    doc_id = j["docid"]
+                    text = j["segment"]
+                    title = j["title"]
+                    heading = j["headings"]
+                    doc_text = "{} {}".format(title, text)
+                    data.append(doc_text)
+                    ids.append(doc_id)
+
+            print("Documents fully loaded")
+            batch_size = 512
+            chunks = [data[i: i + batch_size] for i in range(0, len(data), batch_size)]
+            embds = []
+            for chunk in tqdm(chunks, desc="inference"):
+                tokens = tokenizer(
+                    chunk,
+                    padding=True,
+                    truncation=True,
+                    return_tensors="pt",
+                    max_length=512,
+                ).to(device)
+                with torch.autocast(
+                    "cuda", dtype=torch.bfloat16
+                ), torch.inference_mode():
+                    embds.append(
+                        model(**tokens)[0][:, 0]
+                        .cpu()
+                        .to(torch.float32)
+                        .detach()
+                        .numpy()
+                    )
+            del data, chunks
+            embds = [item for batch in embds for item in batch]
+            out_data = []
+            for emb, doc_id in zip(embds, ids):
+                out_data.append({"doc_id": doc_id, "embedding": emb})
+            del embds, ids
+            table = pa.Table.from_pylist(out_data)
+            del out_data
+            pq.write_table(table, filename_out)
+        except Exception:
+            pass

scripts/generate_query_embeddings.py

@@ -0,0 +1,66 @@
+import pyarrow as pa
+import pyarrow.parquet as pq
+import torch
+from transformers import AutoModel, AutoTokenizer
+
+query_prefix = "Represent this sentence for searching relevant passages: "
+topic_file_names = [
+    "topics.dl21.txt",
+    "topics.dl22.txt",
+    "topics.dl23.txt",
+    "topics.msmarco-v2-doc.dev.txt",
+    "topics.msmarco-v2-doc.dev2.txt",
+    "topics.rag24.raggy-dev.txt",
+    "topics.rag24.researchy-dev.txt",
+]
+model_names = [
+    "Snowflake/snowflake-arctic-embed-l",
+    "Snowflake/snowflake-arctic-embed-m-v1.5",
+]
+
+for model_name in model_names:
+    print(f"Running query embeddings using {model_name}")
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    model = AutoModel.from_pretrained(
+        model_name,
+        add_pooling_layer=False,
+    )
+    model.eval()
+    device = "cuda"
+    model = model.to(device)
+    for file_name in topic_file_names:
+        short_file_name = ".".join(file_name.split(".")[:-1])
+        data = []
+        print(f"starting on {file_name}")
+        with open(file_name, "r") as f:
+            for line in f:
+                line = line.strip().split("\t")
+                qid = line[0]
+                query_text = line[1]
+                queries_with_prefix = [
+                    "{}{}".format(query_prefix, i) for i in [query_text]
+                ]
+                query_tokens = tokenizer(
+                    queries_with_prefix,
+                    padding=True,
+                    truncation=True,
+                    return_tensors="pt",
+                    max_length=512,
+                )
+                # Compute token embeddings
+                with torch.autocast(
+                    "cuda", dtype=torch.bfloat16
+                ), torch.inference_mode():
+                    query_embeddings = (
+                        model(**query_tokens.to(device))[0][:, 0]
+                        .cpu()
+                        .to(torch.float32)
+                        .detach()
+                        .numpy()[0]
+                    )
+                item = {"id": qid, "text": query_text, "embedding": query_embeddings}
+                data.append(item)
+            table = pa.Table.from_pylist(data)
+            pq.write_table(
+                table, f"{model_name.split('/')[1]}-{short_file_name}.parquet"
+            )

scripts/get_data.sh

@@ -0,0 +1,21 @@
+#  Download and unzip docs
+wget https://msmarco.z22.web.core.windows.net/msmarcoranking/msmarco_v2.1_doc_segmented.tar
+tar -xf /home/mltraining/msmarco_v2.1_doc_segmented.tar
+gunzip /home/mltraining/msmarco_v2.1_doc_segmented/*
+
+# Download Queries 
+wget https://raw.githubusercontent.com/castorini/anserini-tools/master/topics-and-qrels/topics.msmarco-v2-doc.dev.txt
+wget https://raw.githubusercontent.com/castorini/anserini-tools/master/topics-and-qrels/topics.msmarco-v2-doc.dev2.txt
+wget https://raw.githubusercontent.com/castorini/anserini-tools/master/topics-and-qrels/topics.dl21.txt
+wget https://raw.githubusercontent.com/castorini/anserini-tools/master/topics-and-qrels/topics.dl22.txt
+wget https://raw.githubusercontent.com/castorini/anserini-tools/master/topics-and-qrels/topics.dl23.txt
+wget https://raw.githubusercontent.com/castorini/anserini-tools/master/topics-and-qrels/topics.rag24.raggy-dev.txt
+wget https://raw.githubusercontent.com/castorini/anserini-tools/master/topics-and-qrels/topics.rag24.researchy-dev.txt
+
+# Download Qrels
+wget https://raw.githubusercontent.com/castorini/anserini-tools/master/topics-and-qrels/qrels.rag24.raggy-dev.txt
+wget https://raw.githubusercontent.com/castorini/anserini-tools/master/topics-and-qrels/qrels.dl21-doc-msmarco-v2.1.txt
+wget https://raw.githubusercontent.com/castorini/anserini-tools/master/topics-and-qrels/qrels.dl22-doc-msmarco-v2.1.txt
+wget https://raw.githubusercontent.com/castorini/anserini-tools/master/topics-and-qrels/qrels.dl23-doc-msmarco-v2.1.txt
+wget https://raw.githubusercontent.com/castorini/anserini-tools/master/topics-and-qrels/qrels.msmarco-v2.1-doc.dev.txt
+wget https://raw.githubusercontent.com/castorini/anserini-tools/master/topics-and-qrels/qrels.msmarco-v2.1-doc.dev2.txt

scripts/merge_retrieved_shard.py

@@ -0,0 +1,79 @@
+import glob
+import json
+import pickle
+import sys
+from typing import Dict
+
+import numpy as np
+from beir.retrieval.evaluation import EvaluateRetrieval
+
+
+def load_qrels(filename: str) -> Dict:
+    with open(filename, "r") as f:
+        qrels = json.load(f)
+    return qrels
+
+
+def merge_retrieved_shards(
+    suffix: str, output_file: str, top_n: int, qrels: dict, metric: str
+) -> None:
+    shard_files = glob.glob(f"*{suffix}")
+    print(f"There are {len(shard_files)} shards found")
+    merged_results = {}
+    print("Loading All shards")
+    for shard_file in shard_files:
+        print(f"Loading shard {shard_file} ")
+        with open(shard_file, "rb") as f:
+            shard_results = pickle.load(f)
+            for query_id, doc_scores in shard_results.items():
+                if query_id not in merged_results:
+                    merged_results[query_id] = []
+                merged_results[query_id].extend(doc_scores.items())
+    print("Shards all loaded, merging results and sorting by score")
+    run = {}
+    per_query = []
+    for query_id, doc_scores in merged_results.items():
+        if query_id in qrels:
+            doc_score_dict = {}
+            for passage_id, score in doc_scores:
+                doc_id = passage_id.split("#")[
+                    0
+                ]  # everything after # is the passage idenfitier withing a doc
+                if doc_id not in doc_score_dict:
+                    doc_score_dict[doc_id] = (
+                        -1
+                    )  # scores are in range -1 to 1 on similairty so starting at -1 is floor
+                if score > doc_score_dict[doc_id]:
+                    doc_score_dict[doc_id] = score
+            top_docs = sorted(doc_score_dict.items(), key=lambda x: x[1], reverse=True)[
+                :top_n
+            ]
+            run[query_id] = {
+                doc_id: round(score * 100, 2) for doc_id, score in top_docs
+            }
+            scores = EvaluateRetrieval.evaluate(
+                qrels, {query_id: run[query_id]}, k_values=[1, 3, 5, 10, 100, 1000]
+            )
+            scores = {k: v for d in scores for k, v in d.items()}
+            per_query.append(scores[metric])
+    print("Done merging and sorting results, Evaluating and saving run")
+    print(f"There are {len(run)} queries being evaled agaisnt qrels")
+    print(f"There were {len(shard_files)} shards found")
+    print(
+        f"Per Query Score average: {np.array(per_query).mean()} for {metric}. Individual scores{per_query}"
+    )
+    print("Overall Score Numbers:")
+    print(EvaluateRetrieval.evaluate(qrels, run, k_values=[1, 3, 5, 10, 100, 1000]))
+    with open(output_file, "wb") as w:
+        pickle.dump(run, w)
+
+
+if __name__ == "__main__":
+    suffix = sys.argv[1]
+    output_file = sys.argv[2]
+    top_n = int(sys.argv[3])
+    qrel_filename = sys.argv[4]
+    metric = sys.argv[5]
+    merge_retrieved_shards(
+        suffix, output_file, top_n, load_qrels(qrel_filename), metric
+    )

scripts/retrieve.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+# Define common parameters
+base_path="gte-large/"
+prefix="gte-large-en-v1.5"
+num_shards=59
+num_retrieved=100
+dim=1024
+use_faiss=1
+# Loop through the required range
+for i in $(seq 0 $num_shards)
+do
+    python retrieve_from_shard.py $base_path $prefix $i $num_retrieved $dim $use_faiss
+done

scripts/retrieve_from_shard.py

@@ -0,0 +1,101 @@
+import pickle
+import sys
+
+import pyarrow.parquet as pq
+import torch
+import torch.nn.functional as F
+import faiss
+import numpy as np
+
+def main(
+    path: str, query_prefix: str, shard_num: int, retrieval_depth: int, num_dim: int, use_faiss_gpu: bool = False
+) -> None:
+    query_filenames = [
+        "topics.dl21.parquet",
+        "topics.msmarco-v2-doc.dev2.parquet",
+        "topics.dl22.parquet",
+        "topics.rag24.raggy-dev.parquet",
+        "topics.dl23.parquet",
+        "topics.rag24.researchy-dev.parquet",
+        "topics.msmarco-v2-doc.dev.parquet",
+    ]
+    shard_filename = f"{path}{shard_num:02}.parquet"
+    print(f"Starting retrieval on Chunk {shard_num} for {shard_filename}")
+    doc_embeddings = []
+    idx2docid = {}
+    print("Reading Document Embeddings File")
+    table = pq.read_table(shard_filename)
+    print("Parquet file read, looping")
+    print(f"Chunk {shard_filename} loaded with {len(table)} documents")
+    for idx in range(len(table)):
+        doc_id = str(table[0][idx])
+        doc_embeddings.append(table[1][idx].as_py()[:num_dim])
+        idx2docid[idx] = doc_id
+
+    doc_embeddings = torch.tensor(doc_embeddings, dtype=torch.float32)
+    print(f"Embeddings loaded. Size {doc_embeddings.shape}")
+    doc_embeddings = F.normalize(doc_embeddings, p=2, dim=1)
+    print("Document Embeddings normalized")
+    print("Document Embeddings Loaded into index")
+
+    if use_faiss_gpu:
+        # Create a FAISS index on GPU
+        index = faiss.IndexFlatL2(num_dim)
+        index = faiss.index_cpu_to_gpu(faiss.StandardGpuResources(), 0, index)
+        index.add(doc_embeddings.numpy())
+    else:
+        # Use numpy for similarity calculations
+        doc_embeddings_numpy = doc_embeddings.numpy()
+
+    for query_filename in query_filenames:
+        query_embeddings = []
+        retrieved_results = {}
+        idx2query_id = {}
+        query_filename_full = f"{path}{query_prefix}{query_filename}"
+        print(f"Retrieving from {shard_filename} for query set {query_filename_full}")
+        query_embeddings = []
+        print("Loading Query Embedding file")
+        table = pq.read_table(query_filename_full)
+        print("Done loading parquet query file")
+        for idx in range(len(table)):
+            query_id = str(table[0][idx])
+            query_embeddings.append(table[2][idx].as_py()[:num_dim])
+            idx2query_id[idx] = query_id
+        query_embeddings = torch.tensor(query_embeddings, dtype=torch.float32)
+        query_embeddings = F.normalize(query_embeddings, p=2, dim=1)
+        print(f"Query Embeddings loaded with size {query_embeddings.shape}")
+
+        if use_faiss_gpu:
+            # Search the FAISS index on GPU
+            similarities, indices = index.search(query_embeddings.numpy(), retrieval_depth)
+            for idx in range(query_embeddings.shape[0]):
+                qid = idx2query_id[idx]
+                retrieved_results[qid] = {}
+                for jdx in range(retrieval_depth):
+                    idx_doc = int(indices[idx, jdx])
+                    doc_id = idx2docid[idx_doc]
+                    retrieved_results[qid][doc_id] = float(similarities[idx, jdx])
+        else:
+            # Use numpy for similarity calculations
+            for idx in range(query_embeddings.shape[0]):
+                similarities = np.dot(query_embeddings[idx].numpy(), doc_embeddings_numpy.T)
+                top_n = np.argsort(-similarities)[:retrieval_depth]
+                qid = idx2query_id[idx]
+                retrieved_results[qid] = {}
+                for jdx in range(retrieval_depth):
+                    idx_doc = int(top_n[jdx])
+                    doc_id = idx2docid[idx_doc]
+                    retrieved_results[qid][doc_id] = float(similarities[idx_doc])
+
+        with open(f"{shard_num}-{query_prefix}{num_dim}-{query_filename}", "wb") as w:
+            pickle.dump(retrieved_results, w)
+
+
+if __name__ == "__main__":
+    path = sys.argv[1]
+    query_prefix = sys.argv[2]
+    shard_num = int(sys.argv[3])
+    retrieval_depth = int(sys.argv[4])
+    num_dim = int(sys.argv[5])
+    use_faiss_gpu = bool(int(sys.argv[6]))  # 0 for numpy, 1 for FAISS GPU
+    main(path, query_prefix, shard_num, retrieval_depth, num_dim, use_faiss_gpu)