minimal card

README.md

@@ -16,23 +16,8 @@ language:
 
 # kernel-code-embed
 
-A compact **C code embedding model for Linux kernel retrieval**. Ask a question
-in English; it ranks kernel functions by how well they answer it.
-
-Symmetric bi-encoder — queries and code go through the **same** encoder with no
-prefix or instruction prompt.
-
-| | |
-|---|---|
-| parameters | 42.6M |
-| layers / hidden / heads | 8 / 512 / 8 |
-| vocabulary | 32,768 byte-level BPE, built for C |
-| max sequence length | **320** |
-| pooling | mean |
-| output | 512-dim, L2-normalised |
-| size on disk | 162 MB |
-
-## Usage
+A 42.6M-parameter bi-encoder for retrieving **Linux kernel C** from
+natural-language queries. Queries and code use the same encoder, no prefixes.
 
 ```python
 from sentence_transformers import SentenceTransformer
@@ -40,68 +25,13 @@ from sentence_transformers import SentenceTransformer
 model = SentenceTransformer("nethunter2023/kernel-code-embed")
 
 query = "how are free pages coalesced into larger blocks"
-code = """
-static inline void __free_one_page(struct page *page, unsigned long pfn,
-                                   struct zone *zone, unsigned int order,
-                                   int migratetype, fpi_t fpi_flags)
-{
-        ...
-}
-"""
+code = "static inline void __free_one_page(struct page *page, ...) { ... }"
 
 emb = model.encode([query, code], normalize_embeddings=True)
 print(emb @ emb.T)          # cosine similarity
 ```
 
-**Do not raise `max_seq_length` above 320.** Feeding longer inputs measurably
-degrades retrieval quality — in a spot check it moved a correct answer from
-rank 12 to rank 40. Chunk longer functions instead.
-
-## Evaluating this model
-
-Enough detail to reproduce or compare the numbers below.
-
-- **Embeddings:** `normalize_embeddings=True`, mean pooling, 512-dim.
-- **Similarity:** cosine (equivalently, dot product on normalised vectors).
-- **No prompt prefixes** on either side — encode raw query text and raw code.
-- **Sequence length:** leave at 320.
-- **Open retrieval below:** every `.c`/`.h` chunk in Linux v7.1-rc5 as the index
-  (914,554 chunks), 400 held-out kernel-doc anchors as queries, the documented
-  function as the single correct answer.
-- **Hybrid** is dense retrieval fused with BM25 via reciprocal rank fusion.
-- **Closed evaluation:** 2,000 held-out pairs against 4,000 candidates. A
-  deliberately hard setting: the distractors come from the same source files as
-  the answer, so lexical overlap alone does not separate them.
-
-## Results
-
-Open retrieval over the whole kernel — **914,554 candidate chunks**:
-
-| metric | dense | hybrid (dense + BM25 RRF) |
-|---|---|---|
-| recall@1 | 0.8125 | **0.9050** |
-| recall@5 | 0.9375 | **0.9725** |
-| recall@10 | 0.9575 | **0.9775** |
-| recall@50 | 0.9850 | **0.9950** |
-| MRR | 0.8682 | **0.9374** |
-| median rank | 1 | 1 |
-
-The correct function ranks first out of 914,554 candidates 90% of the time.
-
-Closed evaluation, against a lexical baseline:
-
-| metric | BM25 | this model |
-|---|---|---|
-| accuracy@1 | 0.7115 | **0.9225** |
-| NDCG@10 | 0.8297 | **0.9659** |
-
-## Limitations
+512-dim output, mean pooling, L2-normalised — score with cosine similarity.
 
-- **Domain-specific.** Trained on Linux kernel C only. It is not a general-purpose
-  code or text embedding model, and it should not be expected to transfer to
-  other languages or codebases.
-- **Short context.** 320 tokens. Long functions must be chunked.
-- **Evaluated on kernel-doc anchors**, which are written by kernel developers and
-  are more precise than typical end-user questions. Expect lower accuracy on
-  casual or ambiguous phrasing.
-- Licensed GPL-2.0, consistent with its Linux kernel training data.
+`max_seq_length` is **320** and should not be raised; longer inputs degrade
+retrieval. Chunk longer functions instead.