code-daemon-reranker-v1

A cross-encoder reranker for natural-language → code search. It reads a (query, candidate) pair and returns one relevance logit, and re-orders the top candidates of the Code-Daemon hybrid retriever (embeddings + BM25 + code graph).

What makes it different: it was fine-tuned on exactly what it sees when it serves — the candidate pools Code-Daemon's own retriever produces, with the retriever's own near-misses as negatives, and the document text in the form the search actually feeds it. A generic reranker learns from a proxy retriever's mistakes; this one learned from the ones it has to fix.

• ~117M parameters — XLM-RoBERTa, 12 layers × 384 hidden, multilingual 250k vocabulary.
• 2-input ONNX (input_ids, attention_mask, no token_type_ids) → one logit per pair.
• 256 tokens per pair: the query is kept whole, the document's tail is cut.

The weights under this id were replaced on 2026-10-12. Same architecture, same inputs and outputs, same tokenizer; the backbone is now the MIT-licensed hotchpotch/mMiniLMv2-L12-H384 with no ranking stage in front of it. The previous revision (2026-09-13) was warm-started from an MS MARCO-derived ranker and scored 0.006 nDCG@10 higher on the same evaluation; the revision before that, a fine-tune on public pairs, scored below its own untuned base. Engines built for earlier weights are gone from this repository.

Numbers

Ten repositories never seen in training, 6 141 natural-language queries, Code-Daemon's own candidate pools (20 per query) re-scored and replayed offline with the daemon's ranking blend:

• +0.040 nDCG@10 over the retriever alone and +0.010 over the public ranker of the same width, at the same cost — the architecture is the base's, so query latency is unchanged (about 55 ms end to end for retrieval plus 20 pairs on a laptop RTX 5060, TensorRT FP16).
• The gain sits in the middle of the list — hit@3 to hit@5 and MRR. It does not move the first result much.
• The trade is fit, not cost: the model is tuned to Code-Daemon's document shapes. Plain (query, code snippet) pairs work, but that is not what it was tuned on.
• Absolute numbers are low because the queries are single-positive at file level: a relevant neighbouring file scores zero. Read the difference between the rows, not the level.

How to use it

Re-rank the top ~20 candidates of a first-stage retriever. Feed (query, candidate) pairs, sort by logit. The score is a raw logit — compare it within one query, not against a fixed threshold; Code-Daemon takes sigmoid(logit) and blends it with the retriever's score.

import onnxruntime as ort, numpy as np
from transformers import AutoTokenizer

tok  = AutoTokenizer.from_pretrained(".")
sess = ort.InferenceSession("model.onnx", providers=["CPUExecutionProvider"])

def rerank(query, docs, max_len=256):
    enc = tok([query] * len(docs), docs, padding=True, truncation="only_second",
              max_length=max_len, return_tensors="np", return_token_type_ids=False)
    logits = sess.run(None, {"input_ids":      enc["input_ids"].astype(np.int64),
                             "attention_mask": enc["attention_mask"].astype(np.int64)})[0]
    return sorted(zip(logits.reshape(-1).tolist(), docs), reverse=True)   # higher = more relevant

Documents. About 900 characters of code per candidate is what was measured above. Code-Daemon often sends a candidate as a file header plus the matched entity's siblings, with a >>> marker on the candidate itself; the model has seen that form.

Shapes. OpenVINO and Core ML ship batch 16 × seq 256 (Core ML also seq 64 and 128 — route short pairs there). Everything is FP16: under OpenVINO INT8 this graph hits a known access violation on the Intel iGPU.

How it was made

Starts from hotchpotch/mMiniLMv2-L12-H384 — Microsoft's multilingual MiniLM v2 (12 layers × 384, distilled from XLM-RoBERTa Large), a plain masked-language-model encoder — with a freshly initialised [CLS] ranking head, and is fine-tuned with a listwise objective (one positive against up to 16 negatives) on:

• behavioural queries written per code entity by an LLM that was not allowed to use the entity's identifiers — "compare two hash hierarchies and return list of changed paths", not diffMerkleTrees;
• the candidate pools Code-Daemon's retriever returned for those queries, with negatives taken from the pool's uncertain band, over open-source repositories disjoint from the evaluation set.

The checkpoint was selected on the evaluation repositories' pools replayed offline.

Files

License & attribution

Released under the MIT license.

Backbone: hotchpotch/mMiniLMv2-L12-H384 (MIT), Microsoft's Multilingual-MiniLM-L12-H384 distilled from XLM-RoBERTa Large.