Add scripts/ingest.py

scripts/ingest.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python
+"""Build the e-hekim vector index.
+
+    uv run python scripts/ingest.py
+
+Pipeline: load the 14 hospital splits -> clean and deduplicate -> select 1,000
+articles balanced across sources -> chunk -> embed with the document prompt ->
+write to ChromaDB -> export the publishable parquet (url, chunk_text,
+chunk_vector, + metadata).
+
+The Hugging Face token is read from ``.env`` and used only to fetch the source
+dataset. It is never printed.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import logging
+import sys
+import time
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))
+
+import ehekim  # noqa: F401  (applies the torch/Triton compatibility fix first)
+
+import numpy as np
+import pandas as pd
+
+from ehekim.config import (
+    CHUNK_MIN_TOKENS,
+    CHUNK_OVERLAP_TOKENS,
+    CHUNK_TARGET_TOKENS,
+    EMBEDDING_MODEL_ID,
+    PROJECT_ROOT,
+    SOURCE_DATASET_ID,
+    TARGET_ARTICLE_COUNT,
+    get_settings,
+    operator_secrets,
+)
+from ehekim.corpus import (
+    SELECTION_SEED,
+    build_chunk_records,
+    clean_articles,
+    load_raw_articles,
+    select_articles,
+)
+from ehekim.embedding import Embedder
+from ehekim.vectorstore import VectorStore
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
+logger = logging.getLogger("ingest")
+
+DATA_DIR = PROJECT_ROOT / "data"
+PARQUET_PATH = DATA_DIR / "ehekim_chunks.parquet"
+MANIFEST_PATH = DATA_DIR / "ingest_manifest.json"
+
+
+def parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(description="e-hekim ingestion")
+    p.add_argument("--articles", type=int, default=TARGET_ARTICLE_COUNT,
+                   help="Number of articles to select (default: 1000).")
+    p.add_argument("--batch-size", type=int, default=16, help="Embedding batch size.")
+    p.add_argument("--device", default=None, help="Force a torch device (cuda/cpu).")
+    p.add_argument("--seed", type=int, default=SELECTION_SEED)
+    p.add_argument("--no-parquet", action="store_true", help="Skip the parquet export.")
+    return p.parse_args()
+
+
+def main() -> int:
+    args = parse_args()
+    settings = get_settings()
+    started = time.time()
+
+    token = operator_secrets().get("HUGGINGFACE_TOKEN")
+    logger.info("Kaynak veri kümesi indiriliyor: %s", SOURCE_DATASET_ID)
+    raw = load_raw_articles(SOURCE_DATASET_ID, token=token)
+    logger.info("Ham makale sayısı: %s", len(raw))
+
+    cleaned = clean_articles(raw)
+    logger.info("Temizleme sonrası: %s makale", len(cleaned))
+
+    selected = select_articles(cleaned, target=args.articles, seed=args.seed)
+    per_source = selected.groupby("source").size().to_dict()
+    logger.info("Seçilen makale: %s | kaynak dağılımı: %s", len(selected), per_source)
+
+    logger.info("Embedding modeli yükleniyor: %s", EMBEDDING_MODEL_ID)
+    embedder = Embedder(device=args.device, batch_size=args.batch_size)
+
+    logger.info("Parçalama başlıyor (hedef=%s, örtüşme=%s token)",
+                CHUNK_TARGET_TOKENS, CHUNK_OVERLAP_TOKENS)
+    t0 = time.time()
+    records = build_chunk_records(selected, embedder.tokenizer)
+    if not records:
+        logger.error("Hiç parça üretilemedi.")
+        return 1
+    token_counts = np.array([r.token_count for r in records])
+    logger.info(
+        "%s parça üretildi (%.1fs) | token ort=%.1f medyan=%s min=%s maks=%s",
+        len(records), time.time() - t0, token_counts.mean(),
+        int(np.median(token_counts)), token_counts.min(), token_counts.max(),
+    )
+
+    logger.info("Vektörler hesaplanıyor (%s)...", embedder.device)
+    t0 = time.time()
+    vectors = embedder.encode_documents(
+        [r.chunk_text for r in records],
+        titles=[r.title for r in records],
+        show_progress=True,
+    )
+    logger.info("Embedding tamamlandı: %s vektör, %.1fs", vectors.shape[0], time.time() - t0)
+
+    if vectors.shape[1] != embedder.dimension:
+        logger.error("Beklenmeyen vektör boyutu: %s", vectors.shape[1])
+        return 1
+
+    logger.info("ChromaDB koleksiyonu yeniden oluşturuluyor: %s", settings.collection_name)
+    store = VectorStore(settings.chroma_dir, settings.collection_name)
+    store.recreate()
+    store.add(
+        ids=[r.chunk_id for r in records],
+        embeddings=vectors,
+        documents=[r.chunk_text for r in records],
+        metadatas=[r.metadata() for r in records],
+    )
+    indexed = store.count()
+    logger.info("Dizine eklendi: %s parça", indexed)
+    if indexed != len(records):
+        logger.error("Dizin sayısı uyuşmuyor: %s != %s", indexed, len(records))
+        return 1
+
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    if not args.no_parquet:
+        # Column order matches the delivery schema: url, chunk_text, chunk_vector
+        # first, optional metadata after.
+        frame = pd.DataFrame(
+            {
+                "url": [r.url for r in records],
+                "chunk_text": [r.chunk_text for r in records],
+                "chunk_vector": [v.astype(np.float32).tolist() for v in vectors],
+                "chunk_id": [r.chunk_id for r in records],
+                "parent_id": [r.parent_id for r in records],
+                "title": [r.title for r in records],
+                "__source": [r.source for r in records],
+                "chunk_index": [r.chunk_index for r in records],
+                "token_count": [r.token_count for r in records],
+            }
+        )
+        frame.to_parquet(PARQUET_PATH, index=False)
+        size_mb = PARQUET_PATH.stat().st_size / 1e6
+        logger.info("Parquet yazıldı: %s (%.1f MB)", PARQUET_PATH, size_mb)
+
+    manifest = {
+        "source_dataset": SOURCE_DATASET_ID,
+        "embedding_model": EMBEDDING_MODEL_ID,
+        "embedding_dim": int(vectors.shape[1]),
+        "selection_seed": args.seed,
+        "raw_articles": int(len(raw)),
+        "cleaned_articles": int(len(cleaned)),
+        "selected_articles": int(len(selected)),
+        "articles_per_source": {k: int(v) for k, v in per_source.items()},
+        "chunks": len(records),
+        "chunk_target_tokens": CHUNK_TARGET_TOKENS,
+        "chunk_overlap_tokens": CHUNK_OVERLAP_TOKENS,
+        "chunk_min_tokens": CHUNK_MIN_TOKENS,
+        "token_stats": {
+            "mean": float(token_counts.mean()),
+            "median": float(np.median(token_counts)),
+            "p95": float(np.percentile(token_counts, 95)),
+            "min": int(token_counts.min()),
+            "max": int(token_counts.max()),
+        },
+        "chunks_per_article": round(len(records) / max(1, len(selected)), 2),
+        "collection": settings.collection_name,
+        "elapsed_seconds": round(time.time() - started, 1),
+    }
+    MANIFEST_PATH.write_text(json.dumps(manifest, ensure_ascii=False, indent=2), encoding="utf-8")
+    logger.info("Manifest yazıldı: %s", MANIFEST_PATH)
+    logger.info("Bitti (%.1fs).", time.time() - started)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())