Upload baa-ai-Embedding-Reranker-v1

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+embedder/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+reranker/tokenizer.json filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,24 @@
+baa-ai-Embedding-Reranker-v1 — Proprietary License
+Copyright (c) 2026 BAA AI (Black Sheep AI). All rights reserved.
+
+1. SCOPE. This license governs the "BAA Contributions" in this package: the
+   shared word-embedding architecture and configuration, the router / loader
+   code (modeling_baa.py), the model packaging, BAA AI's weight contributions,
+   the model card, and associated documentation.
+
+2. GRANT. No right to use, reproduce, modify, distribute, sublicense, or create
+   derivative works of the BAA Contributions is granted except under a separate
+   written agreement with BAA AI (Black Sheep AI).
+
+3. THIRD-PARTY COMPONENT. This package incorporates the xlm-roberta-large
+   backbone, provided under the MIT License — see LICENSE-xlm-roberta-large.txt.
+   The MIT terms govern that backbone component only; nothing in this license
+   limits any rights you have under the MIT License with respect to it.
+
+4. NO WARRANTY. THE PACKAGE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO MERCHANTABILITY, FITNESS FOR
+   A PARTICULAR PURPOSE, AND NONINFRINGEMENT. IN NO EVENT SHALL BAA AI BE LIABLE
+   FOR ANY CLAIM, DAMAGES, OR OTHER LIABILITY ARISING FROM OR IN CONNECTION WITH
+   THE PACKAGE OR ITS USE.
+
+Contact: BAA AI (Black Sheep AI) — baa.ai

LICENSE-xlm-roberta-large.txt

@@ -0,0 +1,23 @@
+Backbone component: xlm-roberta-large — MIT License
+
+MIT License
+
+Copyright (c) Facebook, Inc. and its affiliates.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

MODEL_CARD.md

@@ -0,0 +1,42 @@
+# baa-ai-Embedding-Reranker-v1
+
+Unified **embedder + reranker** in one package, sharing a single XLM-RoBERTa-large word-embedding table.
+By BAA AI (Black Sheep AI).
+
+## What it is
+A two-role retrieval model over a **shared input word-embedding matrix** (250002x1024 ~ 256M params, stored
+once). Validated finding: the word-embedding table is fully shareable between a bi-encoder embedder and a
+cross-encoder reranker (both built on `xlm-roberta-large`) at **zero quality loss**, while the transformer
+*layers* are NOT mergeable. So we keep each role's native layers + head and dedupe only the embedding table.
+
+- **Embed role:** bi-encoder. 1024-d, CLS-pool, L2-normalized. Use `"query: "` prefix on queries.
+- **Rerank role:** cross-encoder. Single relevance logit per (query, doc) pair.
+- **Router:** trivial — call `.embed(...)` or `.rerank(...)`.
+
+## Footprint
+~**0.77x** the two separate models (the 256M word-embedding table is stored once and tied at load), with
+**no quality loss** and **no retraining**. Disk: the reranker's word-embedding copy is stripped and injected
+from the embedder at load.
+
+## Eval (450-query ML-PDF holdout)
+| Role | hit@3 | note |
+|---|---|---|
+| Embed (dense retrieval) | 0.9511 | == standalone bi-encoder baseline |
+| Rerank (full pipeline)  | 0.9511 | == standalone cross-encoder baseline |
+Both identical to the two-model baseline; sharing the word-embedding table is a no-op on quality.
+
+## Usage
+```python
+from modeling_baa import BaaEmbeddingReranker
+m = BaaEmbeddingReranker()                       # loads embedder + reranker (shared word-emb)
+qv = m.embed(["my query"], is_query=True)        # 1024-d normalized
+dv = m.embed(["doc a", "doc b"])                 # doc embeddings
+ranked = m.rerank("my query", ["doc a","doc b"], top_k=10)   # [(doc, score), ...]
+```
+
+## License
+- **BAA Contributions** (shared-embedding architecture, router/loader code, packaging, weights, docs) are
+  **proprietary to BAA AI (Black Sheep AI)** — see `LICENSE`.
+- Incorporates the `xlm-roberta-large` backbone under the **MIT License** — see `LICENSE-xlm-roberta-large.txt`.
+
+Build: shared-embedding MoE (Experiment A, 2026-06-22).

NOTICE

@@ -0,0 +1,5 @@
+baa-ai-Embedding-Reranker-v1
+Copyright (c) 2026 BAA AI (Black Sheep AI). All rights reserved.
+
+BAA Contributions: proprietary — see LICENSE.
+Backbone: xlm-roberta-large — MIT License — see LICENSE-xlm-roberta-large.txt.

README.md

@@ -0,0 +1,85 @@
+---
+license: other
+license_name: baa-proprietary
+library_name: baa-embedding-reranker
+tags: [embeddings, reranker, retrieval, rag, cross-encoder, bi-encoder]
+---
+
+# baa-ai-Embedding-Reranker-v1-4bit
+
+A **single package that does both embedding (retrieval) and reranking** for RAG / search pipelines,
+by **BAA AI (Black Sheep AI)**. The bi-encoder embedder and cross-encoder reranker share one
+XLM-RoBERTa-large word-embedding table (stored once). This is the **4-bit** build (group-64 int4 Linear weights; ~2x smaller download, same hit@3).
+
+- **Embed (bi-encoder):** 1024-d, L2-normalized. Prefix queries with `"query: "`.
+- **Rerank (cross-encoder):** relevance score per (query, document) pair.
+- One class, two methods: `.embed(...)` and `.rerank(...)`.
+
+## Install
+```bash
+pip install -r requirements.txt
+```
+The package is self-contained — the loader lives in `modeling_baa.py` and reconstructs the model from the
+files in this folder. Works on CPU, Apple Silicon (MPS), and CUDA.
+
+## Load into memory
+```python
+from modeling_baa import BaaEmbeddingReranker
+
+# point at the downloaded folder (or "." if you cd into it). Auto-selects mps/cuda/cpu.
+model = BaaEmbeddingReranker("path/to/baa-ai-Embedding-Reranker-v1-4bit")
+# force a device if you want: BaaEmbeddingReranker("...", device="cpu")
+```
+
+## Embed — dense retrieval
+```python
+import numpy as np
+
+docs = ["Paris is the capital of France.", "The mitochondria is the powerhouse of the cell."]
+doc_vecs = model.embed(docs)                       # (2, 1024) float32, L2-normalized
+q_vec    = model.embed(["What is the capital of France?"], is_query=True)[0]   # note is_query=True
+
+scores = doc_vecs @ q_vec                          # cosine (vectors are normalized)
+top = int(np.argmax(scores))
+print("best doc:", docs[top], "score:", float(scores[top]))
+```
+
+## Rerank — order candidates for a query
+```python
+query = "What is the capital of France?"
+candidates = ["Paris is the capital of France.",
+              "Berlin is the capital of Germany.",
+              "France is in western Europe."]
+
+ranked = model.rerank(query, candidates, top_k=3)  # [(doc, score), ...] best-first
+for doc, score in ranked:
+    print(round(score, 2), doc)
+```
+
+## End-to-end RAG retrieval (embed -> shortlist -> rerank)
+```python
+import numpy as np
+
+# 1) index your corpus once
+corpus = ["...doc 1...", "...doc 2...", "...", "...doc N..."]
+corpus_vecs = model.embed(corpus)                  # (N, 1024)
+
+def search(query, k_dense=50, k_final=5):
+    qv = model.embed([query], is_query=True)[0]
+    # 2) dense shortlist
+    sims = corpus_vecs @ qv
+    shortlist = np.argsort(-sims)[:k_dense]
+    # 3) rerank the shortlist
+    cand = [corpus[i] for i in shortlist]
+    return model.rerank(query, cand, top_k=k_final)
+
+print(search("your question here"))
+```
+
+## Performance
+Validated on a 450-query holdout: hit@3 = **0.9511** (fp16) / **0.9556** (4-bit) — quantization is free here
+because the cross-encoder absorbs it. This is the **4-bit** build (group-64 int4 Linear weights; ~2x smaller download, same hit@3).
+
+## License
+- **BAA Contributions** (architecture, loader, packaging, weights, docs): **proprietary** — see `LICENSE`.
+- Backbone `xlm-roberta-large`: **MIT** — see `LICENSE-xlm-roberta-large.txt`.

config.json

@@ -0,0 +1,20 @@
+{
+  "model_type": "baa-embedding-reranker",
+  "name": "baa-ai-Embedding-Reranker-v1-4bit",
+  "version": "1",
+  "license": "Proprietary \u2014 BAA AI (Black Sheep AI); xlm-roberta-large backbone under MIT",
+  "architecture": "shared-word-embedding MoE (one XLM-R-large word-embedding table shared across the embedder and reranker stacks)",
+  "roles": {
+    "embed": "1024-d bi-encoder, CLS-pool, normalized, 'query: ' prefix for queries",
+    "rerank": "cross-encoder, single relevance logit"
+  },
+  "backbone": "xlm-roberta-large (MIT)",
+  "eval": {
+    "holdout": "450-q ML-PDF",
+    "embed_hit@3": 0.9511,
+    "rerank_pipeline_hit@3": 0.9511,
+    "footprint_vs_two_models": "~0.77x (shared word-embeddings, ~256M params stored once)"
+  },
+  "loader": "modeling_baa.py :: BaaEmbeddingReranker",
+  "quantization": "group-64 int4 (RTN), fp16 compute"
+}

embedder/config.json

@@ -0,0 +1,33 @@
+{
+  "add_cross_attention": false,
+  "architectures": [
+    "XLMRobertaModel"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "bos_token_id": 0,
+  "classifier_dropout": null,
+  "dtype": "float16",
+  "eos_token_id": 2,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 1024,
+  "initializer_range": 0.02,
+  "intermediate_size": 4096,
+  "is_decoder": false,
+  "layer_norm_eps": 1e-05,
+  "matryoshka_dimensions": [
+    256
+  ],
+  "max_position_embeddings": 8194,
+  "model_type": "xlm-roberta",
+  "num_attention_heads": 16,
+  "num_hidden_layers": 24,
+  "output_past": true,
+  "pad_token_id": 1,
+  "position_embedding_type": "absolute",
+  "tie_word_embeddings": true,
+  "transformers_version": "5.12.1",
+  "type_vocab_size": 1,
+  "use_cache": true,
+  "vocab_size": 250002
+}

embedder/config_sentence_transformers.json

@@ -0,0 +1,14 @@
+{
+  "__version__": {
+    "pytorch": "2.12.1",
+    "sentence_transformers": "5.6.0",
+    "transformers": "5.12.1"
+  },
+  "default_prompt_name": null,
+  "model_type": "SentenceTransformer",
+  "prompts": {
+    "document": "",
+    "query": "query: "
+  },
+  "similarity_fn_name": "cosine"
+}

embedder/modules.json

@@ -0,0 +1,20 @@
+[
+  {
+    "idx": 0,
+    "name": "0",
+    "path": "",
+    "type": "sentence_transformers.base.modules.transformer.Transformer"
+  },
+  {
+    "idx": 1,
+    "name": "1",
+    "path": "1_Pooling",
+    "type": "sentence_transformers.sentence_transformer.modules.pooling.Pooling"
+  },
+  {
+    "idx": 2,
+    "name": "2",
+    "path": "2_Normalize",
+    "type": "sentence_transformers.sentence_transformer.modules.normalize.Normalize"
+  }
+]

embedder/sentence_bert_config.json

@@ -0,0 +1,10 @@
+{
+    "transformer_task": "feature-extraction",
+    "modality_config": {
+        "text": {
+            "method": "forward",
+            "method_output_name": "last_hidden_state"
+        }
+    },
+    "module_output_name": "token_embeddings"
+}

embedder/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:883b037111086fd4dfebbbc9b7cee11e1517b5e0c0514879478661440f137085
+size 17082987

embedder/tokenizer_config.json

@@ -0,0 +1,23 @@
+{
+  "add_prefix_space": true,
+  "backend": "tokenizers",
+  "bos_token": "<s>",
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "<s>",
+  "eos_token": "</s>",
+  "is_local": false,
+  "local_files_only": false,
+  "mask_token": "<mask>",
+  "max_length": 512,
+  "model_max_length": 8192,
+  "pad_to_multiple_of": null,
+  "pad_token": "<pad>",
+  "pad_token_type_id": 0,
+  "padding_side": "right",
+  "sep_token": "</s>",
+  "stride": 0,
+  "tokenizer_class": "XLMRobertaTokenizer",
+  "truncation_side": "right",
+  "truncation_strategy": "longest_first",
+  "unk_token": "<unk>"
+}

modeling_baa.py

@@ -0,0 +1,68 @@
+"""baa-ai-Embedding-Reranker-v1 (4-bit) — standalone embedder+reranker.
+Group-64 int4-packed Linear weights (fp16 for embeddings/LayerNorm/classifier/pooler), dequantized to fp16 at
+load. Pure torch + transformers + safetensors; runs on CPU / Apple MPS / CUDA. API: BaaEmbeddingReranker."""
+import os, json, numpy as np, torch, torch.nn.functional as F
+from safetensors.torch import load_file
+from transformers import AutoConfig, AutoModel, AutoModelForSequenceClassification, AutoTokenizer
+GROUP = 64
+
+def _dequant(st, fk):
+    p = st[fk + "::q"].numpy().astype(np.uint8)
+    L = int(st[fk + "::len"][0]); out_, in_ = int(st[fk + "::shape"][0]), int(st[fk + "::shape"][1])
+    q = np.empty(L, dtype=np.uint8); q[0::2] = p >> 4; q[1::2] = p & 0xF
+    s = st[fk + "::s"].float().numpy().reshape(-1, 1); m = st[fk + "::m"].float().numpy().reshape(-1, 1)
+    w = (q.reshape(-1, GROUP).astype(np.float32) * s + m).reshape(out_, in_)
+    return torch.from_numpy(w)
+
+class BaaEmbeddingReranker:
+    def __init__(self, path=None, device=None):
+        path = path or os.path.dirname(os.path.abspath(__file__))
+        self.device = device or ("mps" if torch.backends.mps.is_available()
+                                  else "cuda" if torch.cuda.is_available() else "cpu")
+        qc = json.load(open(os.path.join(path, "quant_config.json")))
+        st = load_file(os.path.join(path, "weights_q4.safetensors"))
+        shared = st["shared::word_embeddings"]
+        self.emb = AutoModel.from_config(AutoConfig.from_pretrained(os.path.join(path, "embedder")))
+        self.rr = AutoModelForSequenceClassification.from_config(
+            AutoConfig.from_pretrained(os.path.join(path, "reranker")))
+        self._fill(self.emb, st, "emb", "embeddings.word_embeddings.weight", shared, set(qc["emb_q4"]))
+        self._fill(self.rr, st, "rr", "roberta.embeddings.word_embeddings.weight", shared, set(qc["rr_q4"]))
+        self.emb = self.emb.half().to(self.device).eval()
+        self.rr = self.rr.half().to(self.device).eval()
+        self.emb_tok = AutoTokenizer.from_pretrained(os.path.join(path, "embedder"))
+        self.rr_tok = AutoTokenizer.from_pretrained(os.path.join(path, "reranker"))
+
+    def _fill(self, model, st, ns, wemb_key, shared, q4):
+        sd = dict(model.state_dict())
+        for k in list(sd.keys()):
+            if k == wemb_key:
+                sd[k] = shared.to(sd[k].dtype); continue
+            fk = f"{ns}::{k}"
+            if k in q4:
+                sd[k] = _dequant(st, fk).to(sd[k].dtype)
+            elif fk in st:
+                sd[k] = st[fk].to(sd[k].dtype)
+        model.load_state_dict(sd)
+
+    @torch.no_grad()
+    def embed(self, texts, is_query=False, batch_size=32):
+        pref = "query: " if is_query else ""
+        out = []
+        for i in range(0, len(texts), batch_size):
+            enc = self.emb_tok([pref + t for t in texts[i:i+batch_size]], padding=True, truncation=True,
+                               max_length=512, return_tensors="pt").to(self.device)
+            h = self.emb(**enc).last_hidden_state[:, 0]      # CLS
+            out.append(F.normalize(h, dim=-1).float().cpu().numpy())
+        return np.vstack(out)
+
+    @torch.no_grad()
+    def rerank(self, query, docs, top_k=None, batch_size=32):
+        scores = []
+        for i in range(0, len(docs), batch_size):
+            enc = self.rr_tok([(query, d[:2000]) for d in docs[i:i+batch_size]], padding=True,
+                              truncation=True, max_length=512, return_tensors="pt").to(self.device)
+            scores.extend(self.rr(**enc).logits[:, 0].float().cpu().tolist())
+        order = sorted(range(len(docs)), key=lambda j: -scores[j])
+        if top_k:
+            order = order[:top_k]
+        return [(docs[j], scores[j]) for j in order]

quant_config.json

@@ -0,0 +1,303 @@
+{
+ "quant": "q4",
+ "group": 64,
+ "scheme": "group-wise affine RTN (4-bit), fp16 compute",
+ "protected_fp16": [
+  "classifier",
+  "pooler",
+  "embeddings",
+  "LayerNorm"
+ ],
+ "emb_q4": [
+  "encoder.layer.0.attention.output.dense.weight",
+  "encoder.layer.0.attention.self.key.weight",
+  "encoder.layer.0.attention.self.query.weight",
+  "encoder.layer.0.attention.self.value.weight",
+  "encoder.layer.0.intermediate.dense.weight",
+  "encoder.layer.0.output.dense.weight",
+  "encoder.layer.1.attention.output.dense.weight",
+  "encoder.layer.1.attention.self.key.weight",
+  "encoder.layer.1.attention.self.query.weight",
+  "encoder.layer.1.attention.self.value.weight",
+  "encoder.layer.1.intermediate.dense.weight",
+  "encoder.layer.1.output.dense.weight",
+  "encoder.layer.10.attention.output.dense.weight",
+  "encoder.layer.10.attention.self.key.weight",
+  "encoder.layer.10.attention.self.query.weight",
+  "encoder.layer.10.attention.self.value.weight",
+  "encoder.layer.10.intermediate.dense.weight",
+  "encoder.layer.10.output.dense.weight",
+  "encoder.layer.11.attention.output.dense.weight",
+  "encoder.layer.11.attention.self.key.weight",
+  "encoder.layer.11.attention.self.query.weight",
+  "encoder.layer.11.attention.self.value.weight",
+  "encoder.layer.11.intermediate.dense.weight",
+  "encoder.layer.11.output.dense.weight",
+  "encoder.layer.12.attention.output.dense.weight",
+  "encoder.layer.12.attention.self.key.weight",
+  "encoder.layer.12.attention.self.query.weight",
+  "encoder.layer.12.attention.self.value.weight",
+  "encoder.layer.12.intermediate.dense.weight",
+  "encoder.layer.12.output.dense.weight",
+  "encoder.layer.13.attention.output.dense.weight",
+  "encoder.layer.13.attention.self.key.weight",
+  "encoder.layer.13.attention.self.query.weight",
+  "encoder.layer.13.attention.self.value.weight",
+  "encoder.layer.13.intermediate.dense.weight",
+  "encoder.layer.13.output.dense.weight",
+  "encoder.layer.14.attention.output.dense.weight",
+  "encoder.layer.14.attention.self.key.weight",
+  "encoder.layer.14.attention.self.query.weight",
+  "encoder.layer.14.attention.self.value.weight",
+  "encoder.layer.14.intermediate.dense.weight",
+  "encoder.layer.14.output.dense.weight",
+  "encoder.layer.15.attention.output.dense.weight",
+  "encoder.layer.15.attention.self.key.weight",
+  "encoder.layer.15.attention.self.query.weight",
+  "encoder.layer.15.attention.self.value.weight",
+  "encoder.layer.15.intermediate.dense.weight",
+  "encoder.layer.15.output.dense.weight",
+  "encoder.layer.16.attention.output.dense.weight",
+  "encoder.layer.16.attention.self.key.weight",
+  "encoder.layer.16.attention.self.query.weight",
+  "encoder.layer.16.attention.self.value.weight",
+  "encoder.layer.16.intermediate.dense.weight",
+  "encoder.layer.16.output.dense.weight",
+  "encoder.layer.17.attention.output.dense.weight",
+  "encoder.layer.17.attention.self.key.weight",
+  "encoder.layer.17.attention.self.query.weight",
+  "encoder.layer.17.attention.self.value.weight",
+  "encoder.layer.17.intermediate.dense.weight",
+  "encoder.layer.17.output.dense.weight",
+  "encoder.layer.18.attention.output.dense.weight",
+  "encoder.layer.18.attention.self.key.weight",
+  "encoder.layer.18.attention.self.query.weight",
+  "encoder.layer.18.attention.self.value.weight",
+  "encoder.layer.18.intermediate.dense.weight",
+  "encoder.layer.18.output.dense.weight",
+  "encoder.layer.19.attention.output.dense.weight",
+  "encoder.layer.19.attention.self.key.weight",
+  "encoder.layer.19.attention.self.query.weight",
+  "encoder.layer.19.attention.self.value.weight",
+  "encoder.layer.19.intermediate.dense.weight",
+  "encoder.layer.19.output.dense.weight",
+  "encoder.layer.2.attention.output.dense.weight",
+  "encoder.layer.2.attention.self.key.weight",
+  "encoder.layer.2.attention.self.query.weight",
+  "encoder.layer.2.attention.self.value.weight",
+  "encoder.layer.2.intermediate.dense.weight",
+  "encoder.layer.2.output.dense.weight",
+  "encoder.layer.20.attention.output.dense.weight",
+  "encoder.layer.20.attention.self.key.weight",
+  "encoder.layer.20.attention.self.query.weight",
+  "encoder.layer.20.attention.self.value.weight",
+  "encoder.layer.20.intermediate.dense.weight",
+  "encoder.layer.20.output.dense.weight",
+  "encoder.layer.21.attention.output.dense.weight",
+  "encoder.layer.21.attention.self.key.weight",
+  "encoder.layer.21.attention.self.query.weight",
+  "encoder.layer.21.attention.self.value.weight",
+  "encoder.layer.21.intermediate.dense.weight",
+  "encoder.layer.21.output.dense.weight",
+  "encoder.layer.22.attention.output.dense.weight",
+  "encoder.layer.22.attention.self.key.weight",
+  "encoder.layer.22.attention.self.query.weight",
+  "encoder.layer.22.attention.self.value.weight",
+  "encoder.layer.22.intermediate.dense.weight",
+  "encoder.layer.22.output.dense.weight",
+  "encoder.layer.23.attention.output.dense.weight",
+  "encoder.layer.23.attention.self.key.weight",
+  "encoder.layer.23.attention.self.query.weight",
+  "encoder.layer.23.attention.self.value.weight",
+  "encoder.layer.23.intermediate.dense.weight",
+  "encoder.layer.23.output.dense.weight",
+  "encoder.layer.3.attention.output.dense.weight",
+  "encoder.layer.3.attention.self.key.weight",
+  "encoder.layer.3.attention.self.query.weight",
+  "encoder.layer.3.attention.self.value.weight",
+  "encoder.layer.3.intermediate.dense.weight",
+  "encoder.layer.3.output.dense.weight",
+  "encoder.layer.4.attention.output.dense.weight",
+  "encoder.layer.4.attention.self.key.weight",
+  "encoder.layer.4.attention.self.query.weight",
+  "encoder.layer.4.attention.self.value.weight",
+  "encoder.layer.4.intermediate.dense.weight",
+  "encoder.layer.4.output.dense.weight",
+  "encoder.layer.5.attention.output.dense.weight",
+  "encoder.layer.5.attention.self.key.weight",
+  "encoder.layer.5.attention.self.query.weight",
+  "encoder.layer.5.attention.self.value.weight",
+  "encoder.layer.5.intermediate.dense.weight",
+  "encoder.layer.5.output.dense.weight",
+  "encoder.layer.6.attention.output.dense.weight",
+  "encoder.layer.6.attention.self.key.weight",
+  "encoder.layer.6.attention.self.query.weight",
+  "encoder.layer.6.attention.self.value.weight",
+  "encoder.layer.6.intermediate.dense.weight",
+  "encoder.layer.6.output.dense.weight",
+  "encoder.layer.7.attention.output.dense.weight",
+  "encoder.layer.7.attention.self.key.weight",
+  "encoder.layer.7.attention.self.query.weight",
+  "encoder.layer.7.attention.self.value.weight",
+  "encoder.layer.7.intermediate.dense.weight",
+  "encoder.layer.7.output.dense.weight",
+  "encoder.layer.8.attention.output.dense.weight",
+  "encoder.layer.8.attention.self.key.weight",
+  "encoder.layer.8.attention.self.query.weight",
+  "encoder.layer.8.attention.self.value.weight",
+  "encoder.layer.8.intermediate.dense.weight",
+  "encoder.layer.8.output.dense.weight",
+  "encoder.layer.9.attention.output.dense.weight",
+  "encoder.layer.9.attention.self.key.weight",
+  "encoder.layer.9.attention.self.query.weight",
+  "encoder.layer.9.attention.self.value.weight",
+  "encoder.layer.9.intermediate.dense.weight",
+  "encoder.layer.9.output.dense.weight"
+ ],
+ "rr_q4": [
+  "roberta.encoder.layer.0.attention.output.dense.weight",
+  "roberta.encoder.layer.0.attention.self.key.weight",
+  "roberta.encoder.layer.0.attention.self.query.weight",
+  "roberta.encoder.layer.0.attention.self.value.weight",
+  "roberta.encoder.layer.0.intermediate.dense.weight",
+  "roberta.encoder.layer.0.output.dense.weight",
+  "roberta.encoder.layer.1.attention.output.dense.weight",
+  "roberta.encoder.layer.1.attention.self.key.weight",
+  "roberta.encoder.layer.1.attention.self.query.weight",
+  "roberta.encoder.layer.1.attention.self.value.weight",
+  "roberta.encoder.layer.1.intermediate.dense.weight",
+  "roberta.encoder.layer.1.output.dense.weight",
+  "roberta.encoder.layer.10.attention.output.dense.weight",
+  "roberta.encoder.layer.10.attention.self.key.weight",
+  "roberta.encoder.layer.10.attention.self.query.weight",
+  "roberta.encoder.layer.10.attention.self.value.weight",
+  "roberta.encoder.layer.10.intermediate.dense.weight",
+  "roberta.encoder.layer.10.output.dense.weight",
+  "roberta.encoder.layer.11.attention.output.dense.weight",
+  "roberta.encoder.layer.11.attention.self.key.weight",
+  "roberta.encoder.layer.11.attention.self.query.weight",
+  "roberta.encoder.layer.11.attention.self.value.weight",
+  "roberta.encoder.layer.11.intermediate.dense.weight",
+  "roberta.encoder.layer.11.output.dense.weight",
+  "roberta.encoder.layer.12.attention.output.dense.weight",
+  "roberta.encoder.layer.12.attention.self.key.weight",
+  "roberta.encoder.layer.12.attention.self.query.weight",
+  "roberta.encoder.layer.12.attention.self.value.weight",
+  "roberta.encoder.layer.12.intermediate.dense.weight",
+  "roberta.encoder.layer.12.output.dense.weight",
+  "roberta.encoder.layer.13.attention.output.dense.weight",
+  "roberta.encoder.layer.13.attention.self.key.weight",
+  "roberta.encoder.layer.13.attention.self.query.weight",
+  "roberta.encoder.layer.13.attention.self.value.weight",
+  "roberta.encoder.layer.13.intermediate.dense.weight",
+  "roberta.encoder.layer.13.output.dense.weight",
+  "roberta.encoder.layer.14.attention.output.dense.weight",
+  "roberta.encoder.layer.14.attention.self.key.weight",
+  "roberta.encoder.layer.14.attention.self.query.weight",
+  "roberta.encoder.layer.14.attention.self.value.weight",
+  "roberta.encoder.layer.14.intermediate.dense.weight",
+  "roberta.encoder.layer.14.output.dense.weight",
+  "roberta.encoder.layer.15.attention.output.dense.weight",
+  "roberta.encoder.layer.15.attention.self.key.weight",
+  "roberta.encoder.layer.15.attention.self.query.weight",
+  "roberta.encoder.layer.15.attention.self.value.weight",
+  "roberta.encoder.layer.15.intermediate.dense.weight",
+  "roberta.encoder.layer.15.output.dense.weight",
+  "roberta.encoder.layer.16.attention.output.dense.weight",
+  "roberta.encoder.layer.16.attention.self.key.weight",
+  "roberta.encoder.layer.16.attention.self.query.weight",
+  "roberta.encoder.layer.16.attention.self.value.weight",
+  "roberta.encoder.layer.16.intermediate.dense.weight",
+  "roberta.encoder.layer.16.output.dense.weight",
+  "roberta.encoder.layer.17.attention.output.dense.weight",
+  "roberta.encoder.layer.17.attention.self.key.weight",
+  "roberta.encoder.layer.17.attention.self.query.weight",
+  "roberta.encoder.layer.17.attention.self.value.weight",
+  "roberta.encoder.layer.17.intermediate.dense.weight",
+  "roberta.encoder.layer.17.output.dense.weight",
+  "roberta.encoder.layer.18.attention.output.dense.weight",
+  "roberta.encoder.layer.18.attention.self.key.weight",
+  "roberta.encoder.layer.18.attention.self.query.weight",
+  "roberta.encoder.layer.18.attention.self.value.weight",
+  "roberta.encoder.layer.18.intermediate.dense.weight",
+  "roberta.encoder.layer.18.output.dense.weight",
+  "roberta.encoder.layer.19.attention.output.dense.weight",
+  "roberta.encoder.layer.19.attention.self.key.weight",
+  "roberta.encoder.layer.19.attention.self.query.weight",
+  "roberta.encoder.layer.19.attention.self.value.weight",
+  "roberta.encoder.layer.19.intermediate.dense.weight",
+  "roberta.encoder.layer.19.output.dense.weight",
+  "roberta.encoder.layer.2.attention.output.dense.weight",
+  "roberta.encoder.layer.2.attention.self.key.weight",
+  "roberta.encoder.layer.2.attention.self.query.weight",
+  "roberta.encoder.layer.2.attention.self.value.weight",
+  "roberta.encoder.layer.2.intermediate.dense.weight",
+  "roberta.encoder.layer.2.output.dense.weight",
+  "roberta.encoder.layer.20.attention.output.dense.weight",
+  "roberta.encoder.layer.20.attention.self.key.weight",
+  "roberta.encoder.layer.20.attention.self.query.weight",
+  "roberta.encoder.layer.20.attention.self.value.weight",
+  "roberta.encoder.layer.20.intermediate.dense.weight",
+  "roberta.encoder.layer.20.output.dense.weight",
+  "roberta.encoder.layer.21.attention.output.dense.weight",
+  "roberta.encoder.layer.21.attention.self.key.weight",
+  "roberta.encoder.layer.21.attention.self.query.weight",
+  "roberta.encoder.layer.21.attention.self.value.weight",
+  "roberta.encoder.layer.21.intermediate.dense.weight",
+  "roberta.encoder.layer.21.output.dense.weight",
+  "roberta.encoder.layer.22.attention.output.dense.weight",
+  "roberta.encoder.layer.22.attention.self.key.weight",
+  "roberta.encoder.layer.22.attention.self.query.weight",
+  "roberta.encoder.layer.22.attention.self.value.weight",
+  "roberta.encoder.layer.22.intermediate.dense.weight",
+  "roberta.encoder.layer.22.output.dense.weight",
+  "roberta.encoder.layer.23.attention.output.dense.weight",
+  "roberta.encoder.layer.23.attention.self.key.weight",
+  "roberta.encoder.layer.23.attention.self.query.weight",
+  "roberta.encoder.layer.23.attention.self.value.weight",
+  "roberta.encoder.layer.23.intermediate.dense.weight",
+  "roberta.encoder.layer.23.output.dense.weight",
+  "roberta.encoder.layer.3.attention.output.dense.weight",
+  "roberta.encoder.layer.3.attention.self.key.weight",
+  "roberta.encoder.layer.3.attention.self.query.weight",
+  "roberta.encoder.layer.3.attention.self.value.weight",
+  "roberta.encoder.layer.3.intermediate.dense.weight",
+  "roberta.encoder.layer.3.output.dense.weight",
+  "roberta.encoder.layer.4.attention.output.dense.weight",
+  "roberta.encoder.layer.4.attention.self.key.weight",
+  "roberta.encoder.layer.4.attention.self.query.weight",
+  "roberta.encoder.layer.4.attention.self.value.weight",
+  "roberta.encoder.layer.4.intermediate.dense.weight",
+  "roberta.encoder.layer.4.output.dense.weight",
+  "roberta.encoder.layer.5.attention.output.dense.weight",
+  "roberta.encoder.layer.5.attention.self.key.weight",
+  "roberta.encoder.layer.5.attention.self.query.weight",
+  "roberta.encoder.layer.5.attention.self.value.weight",
+  "roberta.encoder.layer.5.intermediate.dense.weight",
+  "roberta.encoder.layer.5.output.dense.weight",
+  "roberta.encoder.layer.6.attention.output.dense.weight",
+  "roberta.encoder.layer.6.attention.self.key.weight",
+  "roberta.encoder.layer.6.attention.self.query.weight",
+  "roberta.encoder.layer.6.attention.self.value.weight",
+  "roberta.encoder.layer.6.intermediate.dense.weight",
+  "roberta.encoder.layer.6.output.dense.weight",
+  "roberta.encoder.layer.7.attention.output.dense.weight",
+  "roberta.encoder.layer.7.attention.self.key.weight",
+  "roberta.encoder.layer.7.attention.self.query.weight",
+  "roberta.encoder.layer.7.attention.self.value.weight",
+  "roberta.encoder.layer.7.intermediate.dense.weight",
+  "roberta.encoder.layer.7.output.dense.weight",
+  "roberta.encoder.layer.8.attention.output.dense.weight",
+  "roberta.encoder.layer.8.attention.self.key.weight",
+  "roberta.encoder.layer.8.attention.self.query.weight",
+  "roberta.encoder.layer.8.attention.self.value.weight",
+  "roberta.encoder.layer.8.intermediate.dense.weight",
+  "roberta.encoder.layer.8.output.dense.weight",
+  "roberta.encoder.layer.9.attention.output.dense.weight",
+  "roberta.encoder.layer.9.attention.self.key.weight",
+  "roberta.encoder.layer.9.attention.self.query.weight",
+  "roberta.encoder.layer.9.attention.self.value.weight",
+  "roberta.encoder.layer.9.intermediate.dense.weight",
+  "roberta.encoder.layer.9.output.dense.weight"
+ ]
+}

requirements.txt

@@ -0,0 +1,4 @@
+torch>=2.2
+transformers>=4.40
+safetensors>=0.4
+numpy>=1.24

reranker/config.json

@@ -0,0 +1,36 @@
+{
+  "add_cross_attention": false,
+  "architectures": [
+    "XLMRobertaForSequenceClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "bos_token_id": 0,
+  "classifier_dropout": null,
+  "dtype": "float16",
+  "eos_token_id": 2,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 1024,
+  "id2label": {
+    "0": "LABEL_0"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 4096,
+  "is_decoder": false,
+  "label2id": {
+    "LABEL_0": 0
+  },
+  "layer_norm_eps": 1e-05,
+  "max_position_embeddings": 514,
+  "model_type": "xlm-roberta",
+  "num_attention_heads": 16,
+  "num_hidden_layers": 24,
+  "output_past": true,
+  "pad_token_id": 1,
+  "position_embedding_type": "absolute",
+  "tie_word_embeddings": true,
+  "transformers_version": "5.12.1",
+  "type_vocab_size": 1,
+  "use_cache": true,
+  "vocab_size": 250002
+}

reranker/config_sentence_transformers.json

@@ -0,0 +1,11 @@
+{
+  "__version__": {
+    "pytorch": "2.12.1",
+    "sentence_transformers": "5.6.0",
+    "transformers": "5.12.1"
+  },
+  "activation_fn": "torch.nn.modules.activation.Sigmoid",
+  "default_prompt_name": null,
+  "model_type": "CrossEncoder",
+  "prompts": {}
+}

reranker/modules.json

@@ -0,0 +1,8 @@
+[
+  {
+    "idx": 0,
+    "name": "0",
+    "path": "",
+    "type": "sentence_transformers.base.modules.transformer.Transformer"
+  }
+]

reranker/sentence_bert_config.json

@@ -0,0 +1,10 @@
+{
+    "transformer_task": "sequence-classification",
+    "modality_config": {
+        "text": {
+            "method": "forward",
+            "method_output_name": "logits"
+        }
+    },
+    "module_output_name": "scores"
+}

reranker/tokenizer.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:85e62d2d9c5fb57ba5cc374e1d0c0016945909d79bd60ad381d08dea3ca80d0e
+size 17098084

reranker/tokenizer_config.json

@@ -0,0 +1,17 @@
+{
+  "add_prefix_space": true,
+  "backend": "tokenizers",
+  "bos_token": "<s>",
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "<s>",
+  "eos_token": "</s>",
+  "is_local": false,
+  "local_files_only": false,
+  "mask_token": "<mask>",
+  "model_max_length": 512,
+  "pad_token": "<pad>",
+  "sep_token": "</s>",
+  "sp_model_kwargs": {},
+  "tokenizer_class": "XLMRobertaTokenizer",
+  "unk_token": "<unk>"
+}

weights_q4.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7cef184a83e9189c2215d308bacf20b20c433a8defe76d66af507f2fcb199612
+size 875305986