| """Minimal pluggable vector store for the SCUT-SS RAG dataset.
|
|
|
| Backends
|
| tfidf : char n-gram TF-IDF (offline, no model download, good baseline for Chinese)
|
| sbert : sentence-transformers dense embeddings (needs `pip install sentence-transformers`)
|
| openai : any OpenAI-compatible /embeddings endpoint (set EMBEDDING_* env vars)
|
|
|
| Layout of <out_dir>:
|
| meta.json backend / model / count
|
| chunks.jsonl the indexed chunks (aligned with matrix rows)
|
| <backend files>
|
| """
|
|
|
| import json
|
| import os
|
| import sys
|
| from pathlib import Path
|
|
|
| for _s in (sys.stdout, sys.stderr):
|
| try:
|
| _s.reconfigure(encoding="utf-8", errors="replace")
|
| except Exception:
|
| pass
|
|
|
|
|
| def load_chunks(path):
|
| return [json.loads(l) for l in open(path, encoding="utf-8") if l.strip()]
|
|
|
|
|
| class Backend:
|
| name = "base"
|
|
|
| def build(self, texts, out_dir):
|
| raise NotImplementedError
|
|
|
| def load(self, out_dir):
|
| raise NotImplementedError
|
|
|
| def encode_query(self, query):
|
| raise NotImplementedError
|
|
|
| def top_k(self, qvec, k):
|
| raise NotImplementedError
|
|
|
|
|
| def _char_ngrams(text, sizes=(1, 2)):
|
| """Character n-grams with boundary padding — works for Chinese without a tokenizer."""
|
| s = " " + " ".join(text.split()) + " "
|
| out = []
|
| for n in sizes:
|
| for i in range(len(s) - n + 1):
|
| out.append(s[i : i + n])
|
| return out
|
|
|
|
|
| class TfidfBackend(Backend):
|
| """Self-contained char n-gram TF-IDF (numpy + scipy only, no sklearn/pandas)."""
|
|
|
| name = "tfidf"
|
|
|
| def build(self, texts, out_dir):
|
| import numpy as np
|
| import scipy.sparse as sp
|
| from collections import Counter
|
|
|
| n_docs = len(texts)
|
| dfs = Counter()
|
| tfs = []
|
| for t in texts:
|
| c = Counter(_char_ngrams(t))
|
| tfs.append(c)
|
| dfs.update(c.keys())
|
| kept = sorted(g for g, df in dfs.items() if df >= 2)
|
| vocab = {g: i for i, g in enumerate(kept)}
|
| indptr, indices, data = [0], [], []
|
| for c in tfs:
|
| for g, cnt in c.items():
|
| j = vocab.get(g)
|
| if j is None:
|
| continue
|
| indices.append(j)
|
| data.append(1.0 + np.log(cnt))
|
| indptr.append(len(indices))
|
| matrix = sp.csr_matrix((np.asarray(data), np.asarray(indices), np.asarray(indptr)), shape=(n_docs, len(vocab)))
|
| idf = np.log((1 + n_docs) / (1 + np.array([dfs[g] for g in vocab], dtype=float))) + 1.0
|
| matrix = sp.csr_matrix(matrix.multiply(idf))
|
| norms = np.sqrt(np.asarray(matrix.multiply(matrix).sum(axis=1)).ravel()) + 1e-12
|
| matrix = sp.diags(1.0 / norms) @ matrix
|
| matrix = sp.csr_matrix(matrix)
|
| sp.save_npz(str(out_dir / "tfidf.npz"), matrix)
|
| (out_dir / "tfidf_vocab.json").write_text(json.dumps(vocab, ensure_ascii=False), encoding="utf-8")
|
| return {"dim": int(matrix.shape[1]), "nnz": int(matrix.nnz)}
|
|
|
| def load(self, out_dir):
|
| import scipy.sparse as sp
|
|
|
| self.matrix = sp.load_npz(str(out_dir / "tfidf.npz"))
|
| self.vocab = json.loads((out_dir / "tfidf_vocab.json").read_text(encoding="utf-8"))
|
|
|
| def encode_query(self, query):
|
| import numpy as np
|
| import scipy.sparse as sp
|
| from collections import Counter
|
|
|
| c = Counter(_char_ngrams(query))
|
| idx, vals, tot = [], [], 0.0
|
| for g, cnt in c.items():
|
| j = self.vocab.get(g)
|
| if j is None:
|
| continue
|
| v = 1.0 + np.log(cnt)
|
| idx.append(j)
|
| vals.append(v)
|
| tot += v * v
|
| if not idx:
|
| return sp.csr_matrix((1, self.matrix.shape[1]))
|
| q = sp.csr_matrix((np.asarray(vals), np.asarray(idx), np.array([0, len(idx)])), shape=(1, self.matrix.shape[1]))
|
| return sp.csr_matrix(q / (np.sqrt(tot) + 1e-12))
|
|
|
| def top_k(self, qvec, k):
|
| import numpy as np
|
|
|
| scores = (self.matrix @ qvec.T).toarray().ravel()
|
| idx = np.argsort(-scores)[:k]
|
| return [(int(i), float(scores[i])) for i in idx if scores[i] > 0]
|
|
|
|
|
| class SbertBackend(Backend):
|
| name = "sbert"
|
| default_model = "paraphrase-multilingual-MiniLM-L12-v2"
|
|
|
| def __init__(self, model=None):
|
| self.model_name = model or os.environ.get("EMBEDDING_MODEL") or self.default_model
|
|
|
| def build(self, texts, out_dir):
|
| import numpy as np
|
| from sentence_transformers import SentenceTransformer
|
|
|
| model = SentenceTransformer(self.model_name)
|
| emb = model.encode(texts, batch_size=32, show_progress_bar=True, normalize_embeddings=True)
|
| emb = np.asarray(emb, dtype="float32")
|
| np.save(str(out_dir / "embeddings.npy"), emb)
|
| return {"dim": int(emb.shape[1]), "model": self.model_name}
|
|
|
| def load(self, out_dir):
|
| import numpy as np
|
|
|
| self.emb = np.load(str(out_dir / "embeddings.npy"))
|
|
|
| def encode_query(self, query):
|
| from sentence_transformers import SentenceTransformer
|
|
|
| model = SentenceTransformer(self.model_name)
|
| v = model.encode([query], normalize_embeddings=True)
|
| import numpy as np
|
|
|
| return np.asarray(v, dtype="float32")
|
|
|
| def top_k(self, qvec, k):
|
| import numpy as np
|
|
|
| scores = (self.emb @ qvec.T).ravel()
|
| idx = np.argsort(-scores)[:k]
|
| return [(int(i), float(scores[i])) for i in idx]
|
|
|
|
|
| class OpenAIBackend(Backend):
|
| """Any OpenAI-compatible /embeddings endpoint (for students with no local model)."""
|
|
|
| name = "openai"
|
|
|
| def __init__(self, model=None, provider=None):
|
| import llm
|
|
|
| conf = llm.resolve_embedding(provider=provider, model=model)
|
| self.base_url = conf["base_url"]
|
| self.api_key = conf["api_key"]
|
| self.model = conf["model"]
|
|
|
| def _post(self, payload):
|
| if not self.api_key:
|
| raise RuntimeError(
|
| "未配置 embedding 的 API Key：设置 EMBEDDING_API_KEY，或在 config/llm.json 里填写 api_key。"
|
| )
|
| import urllib.request
|
|
|
| req = urllib.request.Request(
|
| f"{self.base_url}/embeddings",
|
| data=json.dumps(payload).encode("utf-8"),
|
| headers={"Content-Type": "application/json", "Authorization": f"Bearer {self.api_key}"},
|
| )
|
| with urllib.request.urlopen(req, timeout=120) as resp:
|
| return json.loads(resp.read().decode("utf-8"))
|
|
|
| def build(self, texts, out_dir):
|
| import numpy as np
|
|
|
| vectors = []
|
| batch = 64
|
| for i in range(0, len(texts), batch):
|
| part = texts[i : i + batch]
|
| data = self._post({"model": self.model, "input": part})
|
| vectors.extend(d["embedding"] for d in data["data"])
|
| emb = np.asarray(vectors, dtype="float32")
|
| emb /= (np.linalg.norm(emb, axis=1, keepdims=True) + 1e-12)
|
| np.save(str(out_dir / "embeddings.npy"), emb)
|
| return {"dim": int(emb.shape[1]), "model": self.model, "base_url": self.base_url}
|
|
|
| def load(self, out_dir):
|
| import numpy as np
|
|
|
| self.emb = np.load(str(out_dir / "embeddings.npy"))
|
|
|
| def encode_query(self, query):
|
| import numpy as np
|
|
|
| data = self._post({"model": self.model, "input": [query]})
|
| v = np.asarray(data["data"][0]["embedding"], dtype="float32")
|
| return v / (np.linalg.norm(v) + 1e-12)
|
|
|
| def top_k(self, qvec, k):
|
| import numpy as np
|
|
|
| scores = self.emb @ qvec
|
| idx = np.argsort(-scores)[:k]
|
| return [(int(i), float(scores[i])) for i in idx]
|
|
|
|
|
| BACKENDS = {"tfidf": TfidfBackend, "sbert": SbertBackend, "openai": OpenAIBackend}
|
|
|
|
|
| def build_index(chunks_path, out_dir, backend="tfidf", model=None, provider=None):
|
| out_dir = Path(out_dir)
|
| out_dir.mkdir(parents=True, exist_ok=True)
|
| chunks = load_chunks(chunks_path)
|
| texts = [c["text"] for c in chunks]
|
| if backend == "openai":
|
| be = OpenAIBackend(model=model, provider=provider)
|
| elif backend == "sbert":
|
| be = SbertBackend(model)
|
| else:
|
| be = BACKENDS[backend]()
|
| info = be.build(texts, out_dir)
|
| meta = {"backend": backend, "n_chunks": len(chunks), **(info or {})}
|
| (out_dir / "meta.json").write_text(json.dumps(meta, ensure_ascii=False, indent=2), encoding="utf-8")
|
| with (out_dir / "chunks.jsonl").open("w", encoding="utf-8") as f:
|
| for c in chunks:
|
| f.write(json.dumps(c, ensure_ascii=False) + "\n")
|
| print(f"built {backend} index: {len(chunks)} chunks -> {out_dir}")
|
| return meta
|
|
|
|
|
| class Index:
|
| def __init__(self, out_dir):
|
| self.dir = Path(out_dir)
|
| self.meta = json.loads((self.dir / "meta.json").read_text(encoding="utf-8"))
|
| self.chunks = load_chunks(self.dir / "chunks.jsonl")
|
| backend = self.meta["backend"]
|
| if backend == "openai":
|
| self.be = OpenAIBackend(model=self.meta.get("model"))
|
| elif backend == "sbert":
|
| self.be = SbertBackend(self.meta.get("model"))
|
| else:
|
| self.be = BACKENDS[backend]()
|
| self.be.load(self.dir)
|
|
|
| def search(self, query, k=5):
|
| return [(self.chunks[i], s) for i, s in self.be.top_k(self.be.encode_query(query), k)]
|
|
|
