Doğruluk Metrikleri: RMSE, MAE, Precision@K, Recall@K, MAP, MRR, NDCG, HR@K — Tam Matematik + NumPy

# metrics/rating_metrics.py — Rating prediction metrikleri
import numpy as np
 
def rmse(predictions: np.ndarray, actuals: np.ndarray) -> float:
    """Root Mean Squared Error."""
    return float(np.sqrt(np.mean((predictions - actuals) ** 2)))
 
 
def mae(predictions: np.ndarray, actuals: np.ndarray) -> float:
    """Mean Absolute Error."""
    return float(np.mean(np.abs(predictions - actuals)))
 
 
def mse(predictions: np.ndarray, actuals: np.ndarray) -> float:
    """Mean Squared Error — RMSE'nin karekökü öncesi."""
    return float(np.mean((predictions - actuals) ** 2))
 
 
# Smoke test
np.random.seed(42)
n = 1000
actuals = np.random.choice([1, 2, 3, 4, 5], size=n, p=[0.05, 0.10, 0.20, 0.35, 0.30])
 
# Model 1: Naive — herkese ortalama ver
mean_rating = actuals.mean()
preds_naive = np.full(n, mean_rating)
 
# Model 2: Düşük gürültülü model
preds_good = actuals + np.random.normal(0, 0.5, n)
 
# Model 3: Outlier yapan model — 5%'i çok kötü tahmin eder
preds_outlier = actuals + np.random.normal(0, 0.2, n)
outlier_mask = np.random.random(n) < 0.05
preds_outlier[outlier_mask] += np.random.choice([-4, 4], outlier_mask.sum())
 
print(f"Naive model         | RMSE: {rmse(preds_naive, actuals):.4f} | MAE: {mae(preds_naive, actuals):.4f}")
print(f"Good model          | RMSE: {rmse(preds_good, actuals):.4f}  | MAE: {mae(preds_good, actuals):.4f}")
print(f"Outlier-prone model | RMSE: {rmse(preds_outlier, actuals):.4f}  | MAE: {mae(preds_outlier, actuals):.4f}")
 
# Çıktı:
# Naive model         | RMSE: 1.0996 | MAE: 0.9170
# Good model          | RMSE: 0.5031 | MAE: 0.4001
# Outlier-prone model | RMSE: 0.9420 | MAE: 0.3950   ← outlier RMSE'yi şişiriyor
#                                                       ama MAE iyi gösteriyor
 

# metrics/topn_metrics.py — Top-N metrikleri (sıfırdan)
import numpy as np
 
def precision_at_k(
    recommended: list[int],   # modelin önerileri, sıralı liste
    ground_truth: set[int],    # gerçek pozitif item'lar
    k: int,
) -> float:
    """Precision@K — önerdiğin ilk K'da doğru oranı."""
    top_k = recommended[:k]
    hits = sum(1 for item in top_k if item in ground_truth)
    return hits / k
 
 
def recall_at_k(
    recommended: list[int],
    ground_truth: set[int],
    k: int,
) -> float:
    """Recall@K — doğruların yüzde kaçını ilk K'da yakaladın."""
    if not ground_truth:
        return 0.0
    top_k = recommended[:k]
    hits = sum(1 for item in top_k if item in ground_truth)
    return hits / len(ground_truth)
 
 
def hit_rate_at_k(
    recommended: list[int],
    ground_truth: set[int],
    k: int,
) -> float:
    """HR@K — en az 1 doğru var mı? 0 ya da 1."""
    top_k = recommended[:k]
    return 1.0 if any(item in ground_truth for item in top_k) else 0.0
 
 
def f1_at_k(p: float, r: float) -> float:
    """F1@K — harmonik ortalama."""
    if p + r == 0:
        return 0.0
    return 2 * p * r / (p + r)
 
 
# Test
recommended = [101, 102, 103, 104, 105, 106, 107, 108, 109, 110]
ground_truth = {103, 105, 108, 999}  # 4 gerçek pozitif
 
print(f"Precision@10: {precision_at_k(recommended, ground_truth, 10):.4f}")
print(f"Recall@10:    {recall_at_k(recommended, ground_truth, 10):.4f}")
print(f"HR@10:        {hit_rate_at_k(recommended, ground_truth, 10):.4f}")
print(f"F1@10:        {f1_at_k(precision_at_k(recommended, ground_truth, 10), recall_at_k(recommended, ground_truth, 10)):.4f}")
 
# Precision@10: 0.3000
# Recall@10:    0.7500   (3/4 yakalandı, 999 dışarıda)
# HR@10:        1.0000
# F1@10:        0.4286
 

# metrics/ranked_metrics.py — Sıralı metrikler
import numpy as np
 
def average_precision_at_k(
    recommended: list[int],
    ground_truth: set[int],
    k: int,
) -> float:
    """AP@K — sıralama-hassas precision."""
    if not ground_truth:
        return 0.0
    top_k = recommended[:k]
    hits = 0
    sum_precisions = 0.0
    for i, item in enumerate(top_k, start=1):
        if item in ground_truth:
            hits += 1
            sum_precisions += hits / i
    return sum_precisions / min(len(ground_truth), k)
 
 
def reciprocal_rank(
    recommended: list[int],
    ground_truth: set[int],
) -> float:
    """RR — ilk doğru hit'in pozisyonunun tersi."""
    for i, item in enumerate(recommended, start=1):
        if item in ground_truth:
            return 1.0 / i
    return 0.0
 
 
def mean_average_precision_at_k(
    all_recommended: list[list[int]],
    all_ground_truth: list[set[int]],
    k: int,
) -> float:
    """MAP@K — tüm kullanıcılar için AP'lerin ortalaması."""
    aps = [
        average_precision_at_k(rec, gt, k)
        for rec, gt in zip(all_recommended, all_ground_truth)
    ]
    return float(np.mean(aps))
 
 
def mean_reciprocal_rank(
    all_recommended: list[list[int]],
    all_ground_truth: list[set[int]],
) -> float:
    """MRR — tüm kullanıcılar için RR'lerin ortalaması."""
    rrs = [
        reciprocal_rank(rec, gt)
        for rec, gt in zip(all_recommended, all_ground_truth)
    ]
    return float(np.mean(rrs))
 
 
# Test
recommended = [101, 102, 103, 104, 105, 106, 107, 108, 109, 110]
ground_truth = {101, 104, 107}
 
print(f"AP@10: {average_precision_at_k(recommended, ground_truth, 10):.4f}")
print(f"RR:    {reciprocal_rank(recommended, ground_truth):.4f}")
 
# AP@10:
#   Pos 1 (101): hit, P@1 = 1/1 = 1.0
#   Pos 4 (104): hit, P@4 = 2/4 = 0.5
#   Pos 7 (107): hit, P@7 = 3/7 = 0.4286
#   AP@10 = (1.0 + 0.5 + 0.4286) / 3 = 0.6429
# RR:    1.0   (ilk hit pozisyon 1)
 

# metrics/ndcg.py — NDCG@K implementasyonu
import numpy as np
 
def dcg_at_k(relevances: list[float], k: int) -> float:
    """Discounted Cumulative Gain — verilen sıralamada."""
    relevances = np.asarray(relevances[:k], dtype=np.float32)
    if len(relevances) == 0:
        return 0.0
    discounts = 1.0 / np.log2(np.arange(2, len(relevances) + 2))
    return float(np.sum(relevances * discounts))
 
 
def ndcg_at_k(
    recommended: list[int],
    ground_truth: dict[int, float] | set[int],
    k: int,
) -> float:
    """
    NDCG@K — normalized.
 
    ground_truth: dict ise {item_id: relevance_score}, set ise binary (rel=1).
    """
    # ground_truth'u dict'e normalize et
    if isinstance(ground_truth, set):
        gt_dict = {item: 1.0 for item in ground_truth}
    else:
        gt_dict = ground_truth
 
    if not gt_dict:
        return 0.0
 
    # Verilen sıralamadaki relevance'lar
    rels_predicted = [gt_dict.get(item, 0.0) for item in recommended[:k]]
 
    # Ideal sıralama — relevance'ları büyükten küçüğe
    ideal_rels = sorted(gt_dict.values(), reverse=True)[:k]
 
    dcg = dcg_at_k(rels_predicted, k)
    idcg = dcg_at_k(ideal_rels, k)
 
    return dcg / idcg if idcg > 0 else 0.0
 
 
# Test (binary)
recommended = [101, 102, 103, 104, 105, 106, 107, 108, 109, 110]
ground_truth_set = {101, 104, 107}
print(f"NDCG@10 (binary): {ndcg_at_k(recommended, ground_truth_set, 10):.4f}")
 
# Test (graded — 5★ rating sistemi)
ground_truth_dict = {101: 5.0, 104: 4.0, 107: 3.0, 999: 5.0}
print(f"NDCG@10 (graded): {ndcg_at_k(recommended, ground_truth_dict, 10):.4f}")
 
# NDCG@10 (binary): 0.8290   ← yukarıdaki manuel hesapla aynı
# NDCG@10 (graded): farklı çünkü relevance ağırlıkları farklı
 

import numpy as np
from metrics.topn_metrics import precision_at_k, recall_at_k, hit_rate_at_k
from metrics.ranked_metrics import average_precision_at_k, reciprocal_rank
from metrics.ndcg import ndcg_at_k
 
recommended = [101, 102, 103, 104, 105, 106, 107, 108, 109, 110]
ground_truth = {101, 104, 107}
 
print(f"Precision@10: {precision_at_k(recommended, ground_truth, 10):.4f}")
print(f"Recall@10:    {recall_at_k(recommended, ground_truth, 10):.4f}")
print(f"HR@10:        {hit_rate_at_k(recommended, ground_truth, 10):.4f}")
print(f"AP@10:        {average_precision_at_k(recommended, ground_truth, 10):.4f}")
print(f"RR:           {reciprocal_rank(recommended, ground_truth):.4f}")
print(f"NDCG@10:      {ndcg_at_k(recommended, ground_truth, 10):.4f}")
 
# Çıktı:
# Precision@10: 0.3000   ← önerimin 30%'i doğru
# Recall@10:    1.0000   ← gerçeklerin 100%'ü top-10'da
# HR@10:        1.0000   ← en az 1 hit var
# AP@10:        0.6429   ← sıra hassas precision
# RR:           1.0000   ← ilk hit pozisyon 1
# NDCG@10:      0.8290   ← sıralama gücünü ölç
 
# 💡 Aynı sıralama 6 farklı sayı veriyor. Hangisi "doğru" olduğu sorulan soruya bağlı.