Datasets:

cihatyldz
/

pusula-tr-robustness

"""
pusula_dense.py — Embedding modelleri icin retriever + calistirma/kaydetme yardimcilari.
Prompt'lar ACIKCA cozumlenir (spec > modelin kendi prompt'lari > bos) ve her zaman encode(prompt=...) ile verilir;
sentence-transformers'in varsayilana sessizce donmesine izin verilmez. Benzerlik numpy ile hesaplanir.
"""
import gc
import hashlib
import json
import os
import time
from dataclasses import asdict, dataclass

import numpy as np

QUERY_PROMPT_KEYS = ["query"]
DOC_PROMPT_KEYS = ["document", "passage", "corpus"]   # sentence-transformers ile ayni sira


@dataclass
class ModelSpec:
    model_id: str
    short: str
    params_m: int
    tier: str = "small"                 # "small" (T4) | "large" (>=30 GB GPU)
    query_prompt: str | None = None     # None → modelin kendi prompt'u, o da yoksa ""
    doc_prompt: str | None = None
    trust_remote_code: bool = False
    max_seq_length: int = 512
    batch_size: int | None = None       # None → parametre sayisina gore
    revision: str | None = None         # model reposunun commit hash'i; dis katkilarda ZORUNLU tutulur


def resolve_prompts(spec, model_prompts):
    mp = model_prompts or {}
    q = spec.query_prompt if spec.query_prompt is not None else next((mp[k] for k in QUERY_PROMPT_KEYS if k in mp), "")
    d = spec.doc_prompt if spec.doc_prompt is not None else next((mp[k] for k in DOC_PROMPT_KEYS if k in mp), "")
    return q or "", d or ""


def auto_batch_size(spec):
    if spec.batch_size:
        return spec.batch_size
    return 128 if spec.params_m <= 150 else 64 if spec.params_m <= 600 else 16 if spec.params_m <= 4500 else 8


def select_dtype(torch, device="cuda"):
    """bf16 yalnizca DONANIMDA destekleniyorsa (compute capability >= 8.0: A100, L4, H100).
    T4 (7.5) icin is_bf16_supported() True donebilir ama bf16 emule edilir ve cok yavastir → fp16."""
    if device != "cuda" or not torch.cuda.is_available():
        return torch.float32
    major, _ = torch.cuda.get_device_capability(0)
    return torch.bfloat16 if major >= 8 else torch.float16


def load_sentence_transformer(spec, device="cuda"):
    """Gercek model yukleme (Colab). transformers surumune gore dogru dtype argumani secilir."""
    import torch
    import transformers
    from sentence_transformers import SentenceTransformer

    dtype = select_dtype(torch, device)
    dtype_key = "dtype" if int(transformers.__version__.split(".")[0]) >= 5 else "torch_dtype"
    extra = {"revision": spec.revision} if spec.revision else {}
    model = SentenceTransformer(spec.model_id, device=device, trust_remote_code=spec.trust_remote_code,
                                model_kwargs={dtype_key: dtype}, **extra)
    model.max_seq_length = min(spec.max_seq_length, model.max_seq_length or spec.max_seq_length)
    return model, str(dtype).replace("torch.", "")


class DenseRetriever:
    def __init__(self, spec, model, dtype_name="?"):
        self.spec, self.model, self.dtype_name = spec, model, dtype_name
        self.name = spec.short
        self.query_prompt, self.doc_prompt = resolve_prompts(spec, getattr(model, "prompts", {}))
        self.batch_size = auto_batch_size(spec)

    def _encode(self, texts, prompt):
        """Bellek yetmezse batch'i yariya indirip AYNI metinleri yeniden dener (8B'yi yarida kaybetmemek icin)."""
        while True:
            try:
                emb = self.model.encode(list(texts), prompt=prompt, batch_size=self.batch_size,
                                        normalize_embeddings=True, convert_to_numpy=True, show_progress_bar=False)
                return np.asarray(emb, dtype=np.float32)
            except Exception as e:
                if not is_oom_error(e) or self.batch_size <= 1:
                    raise
                self.batch_size = max(1, self.batch_size // 2)
                print(f"    ⚠️ GPU belleği yetmedi → batch {self.batch_size} ile yeniden deneniyor")
                free_gpu()

    def index(self, corpus):
        self.doc_ids = list(corpus)
        self.D = self._encode([corpus[d] for d in self.doc_ids], self.doc_prompt)
        return self

    def search(self, queries, k=100, chunk=512):
        qids = list(queries)
        Q = self._encode([queries[q] for q in qids], self.query_prompt)
        run, kk = {}, min(k, len(self.doc_ids))
        for s in range(0, len(qids), chunk):
            S = Q[s:s + chunk] @ self.D.T
            top = np.argpartition(-S, kk - 1, axis=1)[:, :kk]
            for i, q in enumerate(qids[s:s + chunk]):
                run[q] = {self.doc_ids[j]: float(S[i, j]) for j in top[i]}
        return run


def free_gpu(*objs):
    """Temizlik ASLA yeni hata uretmemeli: bozuk CUDA baglaminda empty_cache de patlar."""
    for o in objs:
        del o
    gc.collect()
    try:
        import torch
        if torch.cuda.is_available():
            torch.cuda.empty_cache()
    except Exception:
        pass


FATAL_CUDA_MARKERS = ("device-side assert", "cudaErrorAssert", "illegal memory access", "unspecified launch failure")


def is_oom_error(exc):
    return "OutOfMemory" in type(exc).__name__ or "out of memory" in str(exc).lower()


def is_fatal_cuda_error(exc):
    """GPU baglamini kalici bozan hatalar: ayni Python surecinde baska CUDA islemi yapilamaz."""
    text = f"{type(exc).__name__}: {exc}"
    return any(m in text for m in FATAL_CUDA_MARKERS)


# ═══ Parmak izi + sonuc kaydi: farkli oturumlardan gelen sonuclar ancak ayni benchmark'taysa birlesir ═══
def benchmark_fingerprint(sets, pert_queries):
    h = hashlib.sha256()
    for name in sorted(sets):
        rs = sets[name]
        h.update(name.encode())
        for d in sorted(rs.corpus):
            h.update(f"D|{d}|{rs.corpus[d]}".encode())
        for q in sorted(rs.qrels):
            for d, s in sorted(rs.qrels[q].items()):
                h.update(f"R|{q}|{d}|{s}".encode())
        for p in sorted(pert_queries[name]):
            for q, t in sorted(pert_queries[name][p].items()):
                h.update(f"Q|{p}|{q}|{t}".encode())
    return h.hexdigest()[:16]


def save_result(path, spec, fingerprint, per_query, prompts, dtype_name, seconds, error=None):
    os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
    payload = {"spec": asdict(spec), "fingerprint": fingerprint, "prompts": prompts, "dtype": dtype_name,
               "seconds": seconds, "error": error, "per_query": per_query, "saved_at": time.strftime("%Y-%m-%d %H:%M")}
    with open(path, "w", encoding="utf-8") as f:
        json.dump(payload, f, ensure_ascii=False)


def load_results(paths, fingerprint):
    ok, rejected = {}, []
    for p in paths:
        with open(p, encoding="utf-8") as f:
            r = json.load(f)
        if r.get("fingerprint") != fingerprint:
            rejected.append((os.path.basename(p), r.get("fingerprint")))
        elif r.get("error"):
            rejected.append((os.path.basename(p), "hata: " + r["error"][:80]))
        else:
            ok[r["spec"]["short"]] = r
    return ok, rejected

	"""
	pusula_dense.py — Embedding modelleri icin retriever + calistirma/kaydetme yardimcilari.

	Prompt'lar ACIKCA cozumlenir (spec > modelin kendi prompt'lari > bos) ve her zaman encode(prompt=...) ile verilir;
	sentence-transformers'in varsayilana sessizce donmesine izin verilmez. Benzerlik numpy ile hesaplanir.
	"""
	import gc
	import hashlib
	import json
	import os
	import time
	from dataclasses import asdict, dataclass

	import numpy as np

	QUERY_PROMPT_KEYS = ["query"]
	DOC_PROMPT_KEYS = ["document", "passage", "corpus"] # sentence-transformers ile ayni sira


	@dataclass
	class ModelSpec:
	model_id: str
	short: str
	params_m: int
	tier: str = "small" # "small" (T4) \| "large" (>=30 GB GPU)
	query_prompt: str \| None = None # None → modelin kendi prompt'u, o da yoksa ""
	doc_prompt: str \| None = None
	trust_remote_code: bool = False
	max_seq_length: int = 512
	batch_size: int \| None = None # None → parametre sayisina gore
	revision: str \| None = None # model reposunun commit hash'i; dis katkilarda ZORUNLU tutulur


	def resolve_prompts(spec, model_prompts):
	mp = model_prompts or {}
	q = spec.query_prompt if spec.query_prompt is not None else next((mp[k] for k in QUERY_PROMPT_KEYS if k in mp), "")
	d = spec.doc_prompt if spec.doc_prompt is not None else next((mp[k] for k in DOC_PROMPT_KEYS if k in mp), "")
	return q or "", d or ""


	def auto_batch_size(spec):
	if spec.batch_size:
	return spec.batch_size
	return 128 if spec.params_m <= 150 else 64 if spec.params_m <= 600 else 16 if spec.params_m <= 4500 else 8


	def select_dtype(torch, device="cuda"):
	"""bf16 yalnizca DONANIMDA destekleniyorsa (compute capability >= 8.0: A100, L4, H100).
	T4 (7.5) icin is_bf16_supported() True donebilir ama bf16 emule edilir ve cok yavastir → fp16."""
	if device != "cuda" or not torch.cuda.is_available():
	return torch.float32
	major, _ = torch.cuda.get_device_capability(0)
	return torch.bfloat16 if major >= 8 else torch.float16


	def load_sentence_transformer(spec, device="cuda"):
	"""Gercek model yukleme (Colab). transformers surumune gore dogru dtype argumani secilir."""
	import torch
	import transformers
	from sentence_transformers import SentenceTransformer

	dtype = select_dtype(torch, device)
	dtype_key = "dtype" if int(transformers.__version__.split(".")[0]) >= 5 else "torch_dtype"
	extra = {"revision": spec.revision} if spec.revision else {}
	model = SentenceTransformer(spec.model_id, device=device, trust_remote_code=spec.trust_remote_code,
	model_kwargs={dtype_key: dtype}, **extra)
	model.max_seq_length = min(spec.max_seq_length, model.max_seq_length or spec.max_seq_length)
	return model, str(dtype).replace("torch.", "")


	class DenseRetriever:
	def __init__(self, spec, model, dtype_name="?"):
	self.spec, self.model, self.dtype_name = spec, model, dtype_name
	self.name = spec.short
	self.query_prompt, self.doc_prompt = resolve_prompts(spec, getattr(model, "prompts", {}))
	self.batch_size = auto_batch_size(spec)

	def _encode(self, texts, prompt):
	"""Bellek yetmezse batch'i yariya indirip AYNI metinleri yeniden dener (8B'yi yarida kaybetmemek icin)."""
	while True:
	try:
	emb = self.model.encode(list(texts), prompt=prompt, batch_size=self.batch_size,
	normalize_embeddings=True, convert_to_numpy=True, show_progress_bar=False)
	return np.asarray(emb, dtype=np.float32)
	except Exception as e:
	if not is_oom_error(e) or self.batch_size <= 1:
	raise
	self.batch_size = max(1, self.batch_size // 2)
	print(f" ⚠️ GPU belleği yetmedi → batch {self.batch_size} ile yeniden deneniyor")
	free_gpu()

	def index(self, corpus):
	self.doc_ids = list(corpus)
	self.D = self._encode([corpus[d] for d in self.doc_ids], self.doc_prompt)
	return self

	def search(self, queries, k=100, chunk=512):
	qids = list(queries)
	Q = self._encode([queries[q] for q in qids], self.query_prompt)
	run, kk = {}, min(k, len(self.doc_ids))
	for s in range(0, len(qids), chunk):
	S = Q[s:s + chunk] @ self.D.T
	top = np.argpartition(-S, kk - 1, axis=1)[:, :kk]
	for i, q in enumerate(qids[s:s + chunk]):
	run[q] = {self.doc_ids[j]: float(S[i, j]) for j in top[i]}
	return run


	def free_gpu(*objs):
	"""Temizlik ASLA yeni hata uretmemeli: bozuk CUDA baglaminda empty_cache de patlar."""
	for o in objs:
	del o
	gc.collect()
	try:
	import torch
	if torch.cuda.is_available():
	torch.cuda.empty_cache()
	except Exception:
	pass


	FATAL_CUDA_MARKERS = ("device-side assert", "cudaErrorAssert", "illegal memory access", "unspecified launch failure")


	def is_oom_error(exc):
	return "OutOfMemory" in type(exc).__name__ or "out of memory" in str(exc).lower()


	def is_fatal_cuda_error(exc):
	"""GPU baglamini kalici bozan hatalar: ayni Python surecinde baska CUDA islemi yapilamaz."""
	text = f"{type(exc).__name__}: {exc}"
	return any(m in text for m in FATAL_CUDA_MARKERS)


	# ═══ Parmak izi + sonuc kaydi: farkli oturumlardan gelen sonuclar ancak ayni benchmark'taysa birlesir ═══
	def benchmark_fingerprint(sets, pert_queries):
	h = hashlib.sha256()
	for name in sorted(sets):
	rs = sets[name]
	h.update(name.encode())
	for d in sorted(rs.corpus):
	h.update(f"D\|{d}\|{rs.corpus[d]}".encode())
	for q in sorted(rs.qrels):
	for d, s in sorted(rs.qrels[q].items()):
	h.update(f"R\|{q}\|{d}\|{s}".encode())
	for p in sorted(pert_queries[name]):
	for q, t in sorted(pert_queries[name][p].items()):
	h.update(f"Q\|{p}\|{q}\|{t}".encode())
	return h.hexdigest()[:16]


	def save_result(path, spec, fingerprint, per_query, prompts, dtype_name, seconds, error=None):
	os.makedirs(os.path.dirname(path) or ".", exist_ok=True)
	payload = {"spec": asdict(spec), "fingerprint": fingerprint, "prompts": prompts, "dtype": dtype_name,
	"seconds": seconds, "error": error, "per_query": per_query, "saved_at": time.strftime("%Y-%m-%d %H:%M")}
	with open(path, "w", encoding="utf-8") as f:
	json.dump(payload, f, ensure_ascii=False)


	def load_results(paths, fingerprint):
	ok, rejected = {}, []
	for p in paths:
	with open(p, encoding="utf-8") as f:
	r = json.load(f)
	if r.get("fingerprint") != fingerprint:
	rejected.append((os.path.basename(p), r.get("fingerprint")))
	elif r.get("error"):
	rejected.append((os.path.basename(p), "hata: " + r["error"][:80]))
	else:
	ok[r["spec"]["short"]] = r
	return ok, rejected