Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
1d43f2e99d | ||
|
|
d8ca18083f |
No files matched your search
@@ -0,0 +1,39 @@
|
||||
# Поиск Акылдаша через Codex CLI и локальный RAG
|
||||
|
||||
В лаборатории `/review` пользователь задаёт вопрос на русском или кыргызском. Бэкенд передаёт исходный вопрос в Codex CLI. Codex сам формулирует поисковые запросы, получает статьи из локального индекса и возвращает их идентификаторы. Лаборатория показывает источники и варианты уточнения ситуации. Codex CLI использует подписку ChatGPT. Эмбеддинги рассчитываются локально.
|
||||
|
||||
## 1. Пересобрать корпус для RAG
|
||||
|
||||
- Использовать нормализованные выгрузки ЦБД Минюста КР. В пилот включить двуязычные акты разных типов, в том числе действующие и утратившие силу. Зафиксировать версию выгрузки, коды документов и редакций. Дату принятия, дату вступления в силу и метку редакции хранить отдельно при наличии сведений в источнике.
|
||||
- Группировать фрагменты по статьям и пунктам, сохраняя идентификаторы источника и границы статьи. Для длинных статей использовать окна с перекрытием. Поиск сочетает полнотекстовый и векторный отбор, а также фильтры по языку, статусу и редакции.
|
||||
- Собрать пилотный индекс отдельно. Проверить хеши и покрытие RU/KY, размер текста и векторов, выдачу по номерам актов и разговорным вопросам. Локальный SQLite с FTS5 и точным векторным поиском подходит для выборки. Перед сборкой полного корпуса проверить движок с индексированным векторным поиском, включая замер на OpenSearch с фактическими настройками хранения.
|
||||
- Оценить диск для индекса, модели и runtime, временных файлов и одновременного размещения двух версий индекса. В staging проверить возобновление сборки, обновление изменившихся актов и переключение на предыдущую версию.
|
||||
|
||||
Первый замер и команды повторной сборки описаны в [отчёте пилота](../../tools/rag-pilot/README.md).
|
||||
|
||||
## 2. Установить Codex CLI
|
||||
|
||||
- Проверить уже установленный CLI в WSL и использовать его для локального прогона. Для staging подготовить отдельного непривилегированного воркера с фиксированной версией CLI.
|
||||
- Авторизовать через `codex login --device-auth`, проверить `codex login status` и запуск `codex exec` после перезапуска. Описать обновление и повторную авторизацию воркера. [Авторизация Codex](https://learn.chatgpt.com/docs/auth?surface=cli)
|
||||
|
||||
## 3. Настроить Codex CLI
|
||||
|
||||
- Версионировать постоянные инструкции и скилл правового поиска. Явно активировать скилл на каждом запуске. Скилл задаёт поиск по юридическим терминам, проверку редакций и выбор до трёх уточнений, которые могут изменить релевантные нормы.
|
||||
- Подключить локальный MCP с операциями чтения для поиска и получения статьи в конкретной редакции. Ограничить параметры, объём результата и число поисковых вызовов на вопрос. Изолировать воркер от БД пользователей, секретов и административного доступа VPS.
|
||||
- Зафиксировать схему ответа с идентификаторами фрагментов, вариантами уточнения и статусом поиска. Проверить неполные данные и конфликт редакций. [Скиллы](https://learn.chatgpt.com/docs/build-skills) · [Неинтерактивный режим](https://learn.chatgpt.com/docs/non-interactive-mode)
|
||||
|
||||
## 4. Интегрировать CLI с бэкендом
|
||||
|
||||
- Добавить закрытый режим `/review`. Передавать исходный вопрос, язык, фильтры и выбранную деталь в воркер. Ограничить время и параллельность запусков. Различать отсутствие подходящей нормы, таймаут, потерю авторизации и исчерпание лимита подписки.
|
||||
- Проверять принадлежность возвращённых идентификаторов результатам текущего запуска. Формировать цитаты, редакции и ссылки из корпуса. Версии индекса, скилла и CLI сохранять в снимке выдачи. В метриках хранить длительность этапов и тип сбоя. Объём сохраняемого пользовательского текста согласовать перед широким запуском.
|
||||
|
||||
## 5. Обновить лабораторию `/review`
|
||||
|
||||
- Добавить сравнение обычного поиска и Codex + RAG по одному вопросу. Показать статьи с редакцией, статусом и ссылкой на полный текст. Сохранить оценки, снимки и экспорт отзывов.
|
||||
- После выдачи показать динамические кнопки уточнения и поле «Уточнить ситуацию». При повторном запуске передавать исходный вопрос и выбранную деталь. Показывать применённое уточнение с возможностью убрать его.
|
||||
- Для рецензента показывать фактические запросы к корпусу, кандидатов и длительность этапов.
|
||||
|
||||
## 6. Проверить эффект и подготовить развёртывание
|
||||
|
||||
- Сравнить текущий поиск, прямой поиск по новому индексу и Codex с тем же новым индексом. Использовать размеченные вопросы RU/KY и точные запросы по реквизитам. Измерить попадание нужной статьи в топ‑3 и топ‑10, ошибки ссылок и редакций, пользу уточнения, задержку, сбои и расход лимита подписки.
|
||||
- Уровень риска реализации `HIGH`. Выполнить целевые проверки данных и изоляции, обычный CI и независимое ревью. Сначала staging, затем отдельное решение о публичном запуске. Production-изменения требуют разрешения владельца, проверенного внешнего backup и восстановления, подтверждения ёмкости и готового отката.
|
||||
@@ -0,0 +1,47 @@
|
||||
# Пилот RAG для Акылдаша
|
||||
|
||||
Инструмент `rag_pilot.py` создаёт отдельный SQLite-файл для небольшой двуязычной выборки нормализованных документов Минюста КР. Он объединяет FTS5 и точный поиск по 384-мерным векторам. Эмбеддинги вычисляются через ONNX Runtime на CPU. Поиск открывает файл в режиме чтения. При сборке существующий файл с таким именем не перезаписывается.
|
||||
|
||||
Пилот использует последнюю объявленную редакцию каждого выбранного документа в локальном снимке. Это даёт воспроизводимую выборку для проверки поиска. Для проверки юридической актуальности нужны сведения из официального источника. Например, локальный снимок Трудового кодекса `230021083` содержит редакцию `60` с меткой 23.06.2026. В прошлой диагностике проекта отдельно была зафиксирована более поздняя официальная редакция. См. [диагностику релевантности](../../docs/product/search-relevance-findings-2026-11-03.md).
|
||||
|
||||
## Воспроизведение
|
||||
|
||||
Нужны Python 3.12 или новее с SQLite FTS5 и пакеты `numpy`, `onnxruntime`, `tokenizers`. Скачайте [веса ONNX](https://huggingface.co/intfloat/multilingual-e5-small/blob/main/onnx/model_qint8_avx512_vnni.onnx) как `model.onnx` и [токенизатор](https://huggingface.co/intfloat/multilingual-e5-small/blob/main/onnx/tokenizer.json) как `tokenizer.json` в `tmp/rag-model`. Скрипт проверяет SHA-256 перед загрузкой. После установки зависимостей и загрузки файлов сборка и поиск работают локально.
|
||||
|
||||
Из корня репозитория:
|
||||
|
||||
```text
|
||||
python -m pip install numpy onnxruntime tokenizers
|
||||
python -m unittest discover -s tools/rag-pilot -p "test_*.py"
|
||||
python tools/rag-pilot/rag_pilot.py --model-dir tmp/rag-model build --corpus data/minjust-normalized --index data/rag-pilot/laws-v1.sqlite3 230021083 230029465 230000918 112451 111573
|
||||
python -X utf8 tools/rag-pilot/rag_pilot.py --model-dir tmp/rag-model search --index data/rag-pilot/laws-v1.sqlite3 --language ru "Могут ли меня уволить на испытательном сроке?"
|
||||
python -X utf8 tools/rag-pilot/rag_pilot.py --model-dir tmp/rag-model search --index data/rag-pilot/laws-v1.sqlite3 --language ky "Сыноо мөөнөтүндө жумуштан бошотсо болобу?"
|
||||
```
|
||||
|
||||
Создайте каталог `data/rag-pilot` перед сборкой. Выходной файл, зависимости и веса держите в локальных каталогах проекта. Формат пилотного артефакта — `0.1.0`.
|
||||
|
||||
## Ограничения выборки
|
||||
|
||||
Пять актов подобраны вручную. Их выдача подходит для проверки работоспособности и точности ссылок на фрагменты. Для оценки релевантности понадобится независимый размеченный набор. Точный векторный поиск загружает векторы выбранного языка в память, поэтому расчёт для VPS требует отдельного замера масштабируемого движка.
|
||||
|
||||
## Замер 22 ноября 2026 года
|
||||
|
||||
| Показатель | Результат |
|
||||
|---|---:|
|
||||
| Акты и фрагменты | 5 актов, 797 RU и 858 KY |
|
||||
| SQLite с текстом, FTS5, метаданными и векторами | 10 256 384 байта, 9,78 МиБ |
|
||||
| Векторы float32 в пилотном индексе | 2 542 080 байт, 1 536 байт на фрагмент |
|
||||
| Веса и токенизатор | 129,2 МиБ |
|
||||
| Локальные зависимости Python на Windows | 141,6 МиБ |
|
||||
|
||||
`PRAGMA integrity_check` вернул `ok`. Проверенный SHA-256 файла — `8da4843cdcf8cadcc815512625d9157209a16695c2e2635829df3a02355c85e5`. По разговорному вопросу об увольнении на испытательном статья 24 локальной редакции Трудового кодекса заняла второе место на русском и первое на кыргызском. По точным запросам с номером статьи она заняла первое место на обоих языках. Кыргызские заголовки вида `24-берене`, которые нормализатор иногда размечает как обычные абзацы, распознаются при построении пилота.
|
||||
|
||||
### Оценка места на VPS
|
||||
|
||||
Равномерная случайная выборка из 512 документов манифеста (seed `20261122`) дала 4 310 фрагментов RU/KY по правилу последней редакции локального снимка. Проекция на 209 958 документов даёт 1,77 млн фрагментов. 95-процентный бутстрэп-интервал по документам составляет приблизительно 1,22–2,43 млн. Он описывает неопределённость выборки и не учитывает другой алгоритм нарезки или более свежий корпус.
|
||||
|
||||
```text
|
||||
python tools/rag-pilot/rag_size_sample.py data/minjust-normalized tmp/rag-model/tokenizer.json
|
||||
```
|
||||
|
||||
При плотности хранения пилота это **7–14 ГиБ на один индекс** и около 10,2 ГиБ по центральной оценке. Из них 1,75–3,48 ГиБ занимают сами векторы float32. Для планирования staging стоит заложить **25–40 ГиБ свободного места** на две версии индекса, модель, runtime и временные файлы. Read-only замер `df` на VPS показал **44,1 ГиБ свободно на `/`**. В расчёт не входят исходная выгрузка, исторические редакции, внешние резервные копии и накладные расходы выбранного движка. Размер и пиковое потребление памяти OpenSearch предстоит измерить до развёртывания.
|
||||
@@ -0,0 +1,225 @@
|
||||
"""Build and query an isolated bilingual retrieval pilot on CPU."""
|
||||
|
||||
import argparse
|
||||
from collections import defaultdict
|
||||
from contextlib import closing
|
||||
import hashlib
|
||||
from itertools import batched
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import re
|
||||
import sqlite3
|
||||
import tempfile
|
||||
|
||||
import numpy as np
|
||||
import onnxruntime as ort
|
||||
from tokenizers import Tokenizer
|
||||
|
||||
|
||||
MODEL = "intfloat/multilingual-e5-small"
|
||||
MODEL_FILES = {
|
||||
"model.onnx": "dd476dd0c2514e9b9be83aeb3853fac0763e0bdf4a71645407587d77c48a2d88",
|
||||
"tokenizer.json": "0b44a9d7b51c3c62626640cda0e2c2f70fdacdc25bbbd68038369d14ebdf4c39",
|
||||
}
|
||||
LANGUAGES = ("ru", "ky")
|
||||
DIMENSIONS = 384
|
||||
FORMAT_VERSION = "0.1.0"
|
||||
WINDOW_SIZE = 360
|
||||
WINDOW_STEP = 328
|
||||
KY_ARTICLE = re.compile(r"^\s*\d+(?:[-‑–]\d+)*\s*[-‑–]\s*берене\b", re.IGNORECASE)
|
||||
|
||||
|
||||
class Embedder:
|
||||
def __init__(self, model_dir):
|
||||
for name, expected in MODEL_FILES.items():
|
||||
with (model_dir / name).open("rb") as source:
|
||||
if hashlib.file_digest(source, "sha256").hexdigest() != expected:
|
||||
raise ValueError(f"Unexpected model file checksum: {name}")
|
||||
self.tokenizer = Tokenizer.from_file(str(model_dir / "tokenizer.json"))
|
||||
self.encoder = Tokenizer.from_file(str(model_dir / "tokenizer.json"))
|
||||
self.encoder.enable_truncation(max_length=512)
|
||||
self.encoder.enable_padding(pad_id=self.encoder.token_to_id("<pad>"))
|
||||
options = ort.SessionOptions()
|
||||
options.intra_op_num_threads = min(os.cpu_count() or 1, 6)
|
||||
self.session = ort.InferenceSession(
|
||||
str(model_dir / "model.onnx"), sess_options=options, providers=["CPUExecutionProvider"]
|
||||
)
|
||||
self.input_names = {entry.name for entry in self.session.get_inputs()}
|
||||
|
||||
def embed(self, texts):
|
||||
encoded = self.encoder.encode_batch(texts)
|
||||
mask = np.asarray([item.attention_mask for item in encoded], dtype=np.int64)
|
||||
inputs = {
|
||||
"input_ids": np.asarray([item.ids for item in encoded], dtype=np.int64),
|
||||
"attention_mask": mask,
|
||||
"token_type_ids": np.zeros_like(mask),
|
||||
}
|
||||
hidden = self.session.run(None, {key: inputs[key] for key in self.input_names})[0]
|
||||
pooled = (hidden * mask[:, :, None]).sum(axis=1) / mask.sum(axis=1, keepdims=True)
|
||||
vectors = (pooled / np.linalg.norm(pooled, axis=1, keepdims=True)).astype("<f4")
|
||||
if vectors.shape != (len(texts), DIMENSIONS) or not np.isfinite(vectors).all():
|
||||
raise ValueError("Invalid embedding output")
|
||||
return vectors
|
||||
|
||||
def windows(self, text):
|
||||
offsets = self.tokenizer.encode(text, add_special_tokens=False).offsets
|
||||
for start, end in token_windows(len(offsets)):
|
||||
yield text[offsets[start][0]:offsets[end - 1][1]].strip()
|
||||
|
||||
|
||||
def token_windows(token_count):
|
||||
for start in range(0, token_count, WINDOW_STEP):
|
||||
end = min(start + WINDOW_SIZE, token_count)
|
||||
yield start, end
|
||||
if end == token_count:
|
||||
break
|
||||
|
||||
|
||||
def load_json(path):
|
||||
return json.loads(path.read_text(encoding="utf-8"))
|
||||
|
||||
|
||||
def is_article(fragment, language):
|
||||
return fragment["type"] == "article" or (
|
||||
language == "ky" and KY_ARTICLE.match(fragment["text"]) is not None
|
||||
)
|
||||
|
||||
|
||||
def sections(fragments, code, edition, language):
|
||||
section = []
|
||||
for position, fragment in enumerate(fragments, 1):
|
||||
expected = f"document:{code}:edition:{edition}:lang:{language}:fragment:{position}"
|
||||
if fragment["id"] != expected or fragment["position"] != position:
|
||||
raise ValueError(f"Invalid fragment: {expected}")
|
||||
if fragment["text_sha256"] != hashlib.sha256(fragment["text"].encode()).hexdigest():
|
||||
raise ValueError(f"Fragment checksum mismatch: {expected}")
|
||||
if section and (fragment["type"] == "heading" or is_article(fragment, language)):
|
||||
yield section
|
||||
section = []
|
||||
section.append(fragment)
|
||||
if section:
|
||||
yield section
|
||||
|
||||
|
||||
def corpus_chunks(root, codes, embedder):
|
||||
for code in codes:
|
||||
directory = root / "documents" / code
|
||||
document = load_json(directory / "document.json")
|
||||
if document["source_code"] != code:
|
||||
raise ValueError(f"Wrong document code: {code}")
|
||||
declared = document["editions"][-1]
|
||||
edition = str(declared["source_code"])
|
||||
if not edition.isascii() or not edition.isdecimal():
|
||||
raise ValueError(f"Invalid edition code: {edition}")
|
||||
for language in LANGUAGES:
|
||||
fragments = load_json(directory / "editions" / edition / language / "fragments.json")
|
||||
if not fragments:
|
||||
raise ValueError(f"Missing {language} fragments: {code}/{edition}")
|
||||
title = document["name"][language]
|
||||
status = document["status"][language]
|
||||
for section in sections(fragments, code, edition, language):
|
||||
first = section[0]
|
||||
article = first["text"] if is_article(first, language) else ""
|
||||
text = "\n".join(fragment["text"] for fragment in section)
|
||||
for part, chunk in enumerate(embedder.windows(text), 1):
|
||||
yield (
|
||||
f"{first['id']}:part:{part}", code, edition, language, title, status,
|
||||
declared["name"].get(language), first["position"], section[-1]["position"],
|
||||
first["source_path"], first["source_sha256"], article, chunk,
|
||||
)
|
||||
|
||||
|
||||
def build(root, output, codes, embedder):
|
||||
if output.exists():
|
||||
raise FileExistsError(output)
|
||||
descriptor, name = tempfile.mkstemp(dir=output.parent, suffix=".sqlite3")
|
||||
os.close(descriptor)
|
||||
staging = Path(name)
|
||||
try:
|
||||
with closing(sqlite3.connect(staging)) as db, db:
|
||||
db.executescript("""
|
||||
CREATE TABLE manifest (key TEXT PRIMARY KEY, value TEXT NOT NULL);
|
||||
CREATE TABLE chunks (
|
||||
id TEXT UNIQUE NOT NULL, code TEXT NOT NULL, edition TEXT NOT NULL,
|
||||
language TEXT NOT NULL, title TEXT NOT NULL, status TEXT NOT NULL,
|
||||
edition_label TEXT, first_fragment INTEGER NOT NULL, last_fragment INTEGER NOT NULL,
|
||||
source_path TEXT NOT NULL, source_sha256 TEXT NOT NULL,
|
||||
article TEXT NOT NULL, text TEXT NOT NULL
|
||||
);
|
||||
CREATE INDEX chunks_language ON chunks(language);
|
||||
CREATE TABLE vectors (id INTEGER PRIMARY KEY, value BLOB NOT NULL CHECK(length(value)=1536));
|
||||
CREATE VIRTUAL TABLE lexical USING fts5(title, article, text, content='chunks', tokenize='unicode61');
|
||||
""")
|
||||
db.executemany("INSERT INTO manifest VALUES (?, ?)", (
|
||||
("format", FORMAT_VERSION), ("model", MODEL), ("codes", ",".join(codes)),
|
||||
("model_files_sha256", json.dumps(MODEL_FILES, sort_keys=True)),
|
||||
("edition_policy", "last declared edition in the local snapshot"),
|
||||
))
|
||||
for batch in batched(corpus_chunks(root, codes, embedder), 12):
|
||||
texts = [f"passage: {row[4][:160]}\n{row[-2][:100]}\n{row[-1]}" for row in batch]
|
||||
vectors = embedder.embed(texts)
|
||||
for row, vector in zip(batch, vectors, strict=True):
|
||||
cursor = db.execute("INSERT INTO chunks VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?)", row)
|
||||
db.execute("INSERT INTO vectors VALUES (?, ?)", (cursor.lastrowid, vector.tobytes()))
|
||||
db.execute("INSERT INTO lexical(lexical) VALUES ('rebuild')")
|
||||
db.execute("INSERT INTO lexical(lexical, rank) VALUES ('integrity-check', 1)")
|
||||
if db.execute("PRAGMA integrity_check").fetchone() != ("ok",):
|
||||
raise ValueError("Index integrity check failed")
|
||||
if os.name == "nt":
|
||||
os.rename(staging, output)
|
||||
else:
|
||||
os.link(staging, output)
|
||||
finally:
|
||||
staging.unlink(missing_ok=True)
|
||||
|
||||
|
||||
def search(index, query, language, limit, embedder):
|
||||
words = re.findall(r"[^\W_]+", query, flags=re.UNICODE)
|
||||
if not words:
|
||||
raise ValueError("Query must contain letters or digits")
|
||||
with closing(sqlite3.connect(index.resolve().as_uri() + "?mode=ro", uri=True)) as db:
|
||||
db.row_factory = sqlite3.Row
|
||||
vector_rows = db.execute("""SELECT v.id,v.value FROM chunks c JOIN vectors v ON v.id=c.rowid
|
||||
WHERE c.language=? ORDER BY v.id""", (language,)).fetchall()
|
||||
if not vector_rows:
|
||||
return []
|
||||
matrix = np.frombuffer(b"".join(row["value"] for row in vector_rows), dtype="<f4").reshape(-1, DIMENSIONS)
|
||||
similarities = matrix @ embedder.embed([f"query: {query}"])[0]
|
||||
semantic = [vector_rows[i]["id"] for i in np.argsort(-similarities, kind="stable")[:30]]
|
||||
expression = " OR ".join(f'"{word}"' for word in dict.fromkeys(words))
|
||||
lexical = [row[0] for row in db.execute("""SELECT c.rowid FROM lexical
|
||||
JOIN chunks c ON c.rowid=lexical.rowid WHERE lexical MATCH ? AND c.language=?
|
||||
ORDER BY bm25(lexical), c.rowid LIMIT 30""", (expression, language))]
|
||||
combined = defaultdict(float)
|
||||
for ranking in (semantic, lexical):
|
||||
for rank, rowid in enumerate(ranking, 1):
|
||||
combined[rowid] += 1 / (60 + rank)
|
||||
hits = sorted(combined, key=lambda rowid: (-combined[rowid], rowid))[:limit]
|
||||
return [dict(db.execute("SELECT * FROM chunks WHERE rowid=?", (rowid,)).fetchone()) for rowid in hits]
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("--model-dir", required=True, type=Path)
|
||||
commands = parser.add_subparsers(dest="command", required=True)
|
||||
builder = commands.add_parser("build")
|
||||
builder.add_argument("--corpus", required=True, type=Path)
|
||||
builder.add_argument("--index", required=True, type=Path)
|
||||
builder.add_argument("codes", nargs="+")
|
||||
reader = commands.add_parser("search")
|
||||
reader.add_argument("--index", required=True, type=Path)
|
||||
reader.add_argument("--language", choices=LANGUAGES, required=True)
|
||||
reader.add_argument("--limit", type=int, default=5, choices=range(1, 31), metavar="1..30")
|
||||
reader.add_argument("query")
|
||||
args = parser.parse_args()
|
||||
if args.command == "build":
|
||||
if len(set(args.codes)) != len(args.codes) or not all(code.isascii() and code.isdecimal() for code in args.codes):
|
||||
parser.error("codes must be unique decimal document IDs")
|
||||
build(args.corpus, args.index, args.codes, Embedder(args.model_dir))
|
||||
else:
|
||||
print(json.dumps(search(args.index, args.query, args.language, args.limit, Embedder(args.model_dir)), ensure_ascii=False))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,49 @@
|
||||
"""Estimate latest-edition chunk count with a fixed uniform document sample."""
|
||||
|
||||
import json
|
||||
from pathlib import Path
|
||||
import random
|
||||
import sqlite3
|
||||
import statistics
|
||||
import sys
|
||||
|
||||
from tokenizers import Tokenizer
|
||||
|
||||
from rag_pilot import LANGUAGES, load_json, sections, token_windows
|
||||
|
||||
|
||||
def main(root, tokenizer_file):
|
||||
with sqlite3.connect((root / "manifest.sqlite3").resolve().as_uri() + "?mode=ro", uri=True) as db:
|
||||
codes = [row[0] for row in db.execute("SELECT code FROM documents WHERE state='success' ORDER BY code")]
|
||||
tokenizer = Tokenizer.from_file(str(tokenizer_file))
|
||||
rng = random.Random(20261122)
|
||||
sample = rng.sample(codes, 512)
|
||||
counts = []
|
||||
language_counts = dict.fromkeys(LANGUAGES, 0)
|
||||
for code in sample:
|
||||
directory = root / "documents" / code
|
||||
document = load_json(directory / "document.json")
|
||||
editions = document.get("editions") or []
|
||||
count = 0
|
||||
if editions:
|
||||
for language in language_counts:
|
||||
edition = str(editions[-1]["source_code"])
|
||||
path = directory / "editions" / edition / language / "fragments.json"
|
||||
if not path.is_file():
|
||||
continue
|
||||
blocks = ["\n".join(fragment["text"] for fragment in section)
|
||||
for section in sections(load_json(path), code, edition, language)]
|
||||
encoded = tokenizer.encode_batch(blocks, add_special_tokens=False)
|
||||
windows = sum(1 for entry in encoded for _ in token_windows(len(entry.ids)))
|
||||
language_counts[language] += windows
|
||||
count += windows
|
||||
counts.append(count)
|
||||
# Resample at document level so the language and article lengths stay linked.
|
||||
estimates = sorted(statistics.mean(rng.choices(counts, k=len(counts))) * len(codes) for _ in range(2000))
|
||||
print(json.dumps({"documents": len(codes), "sample": len(sample), "languages": language_counts,
|
||||
"largest_sampled_document": max(counts), "projected_chunks": round(statistics.mean(counts) * len(codes)),
|
||||
"bootstrap_low": round(estimates[50]), "bootstrap_high": round(estimates[1949])}))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main(*map(Path, sys.argv[1:]))
|
||||
@@ -0,0 +1,69 @@
|
||||
import hashlib
|
||||
import json
|
||||
from pathlib import Path
|
||||
import sqlite3
|
||||
import tempfile
|
||||
import unittest
|
||||
|
||||
import numpy as np
|
||||
|
||||
from rag_pilot import DIMENSIONS, build, search
|
||||
|
||||
|
||||
class FixedEmbedder:
|
||||
def windows(self, text):
|
||||
yield text
|
||||
|
||||
def embed(self, texts):
|
||||
vectors = np.zeros((len(texts), DIMENSIONS), dtype="<f4")
|
||||
vectors[:, 0] = 1
|
||||
return vectors
|
||||
|
||||
|
||||
class RagPilotTest(unittest.TestCase):
|
||||
def setUp(self):
|
||||
workspace = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(workspace.cleanup)
|
||||
self.root = Path(workspace.name)
|
||||
self.output = self.root / "pilot.sqlite3"
|
||||
self.embedder = FixedEmbedder()
|
||||
document = self.root / "documents" / "1"
|
||||
self.edition = document / "editions" / "10"
|
||||
for language, text in (("ru", "Статья 1. Испытание"), ("ky", "1-берене. Сыноо")):
|
||||
folder = self.edition / language
|
||||
folder.mkdir(parents=True)
|
||||
item = {"id": f"document:1:edition:10:lang:{language}:fragment:1", "text": text,
|
||||
"type": "article" if language == "ru" else "paragraph", "position": 1,
|
||||
"text_sha256": hashlib.sha256(text.encode()).hexdigest(),
|
||||
"source_path": f"documents/1/editions/10/{language}.html", "source_sha256": "0" * 64}
|
||||
(folder / "fragments.json").write_text(json.dumps([item]), encoding="utf-8")
|
||||
metadata = {"source_code": "1", "name": {"ru": "Тестовый акт", "ky": "Сыноо акты"},
|
||||
"status": {"ru": "Действует", "ky": "Күчүндө"},
|
||||
"editions": [{"source_code": "10", "name": {"ru": "Редакция 10", "ky": "10-редакция"}}]}
|
||||
(document / "document.json").write_text(json.dumps(metadata), encoding="utf-8")
|
||||
|
||||
def test_bilingual_search_returns_source_identity_and_cannot_overwrite(self):
|
||||
build(self.root, self.output, ["1"], self.embedder)
|
||||
for language, query in (("ru", "Испытание"), ("ky", "Сыноо")):
|
||||
hits = search(self.output, f'{query} " OR *', language, 3, self.embedder)
|
||||
self.assertEqual([hit["id"] for hit in hits], [f"document:1:edition:10:lang:{language}:fragment:1:part:1"])
|
||||
self.assertIn(f"{language}.html", hits[0]["source_path"])
|
||||
self.assertTrue(hits[0]["article"])
|
||||
before = self.output.read_bytes()
|
||||
with self.assertRaises(FileExistsError):
|
||||
build(self.root, self.output, ["1"], self.embedder)
|
||||
self.assertEqual(before, self.output.read_bytes())
|
||||
|
||||
def test_corrupt_input_does_not_publish_partial_index(self):
|
||||
path = self.edition / "ky" / "fragments.json"
|
||||
items = json.loads(path.read_text(encoding="utf-8"))
|
||||
items[0]["text"] += " corrupt"
|
||||
path.write_text(json.dumps(items), encoding="utf-8")
|
||||
with self.assertRaisesRegex(ValueError, "checksum"):
|
||||
build(self.root, self.output, ["1"], self.embedder)
|
||||
self.assertFalse(self.output.exists())
|
||||
self.assertEqual(list(self.root.glob("*.sqlite3")), [])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in new issue
Block a user