Beyond-Accuracy: Coverage, Diversity (ILS), Novelty, Serendipity ve Popularity Bias Ölçümü

# metrics/beyond_accuracy.py — Beyond-accuracy metrikleri
import numpy as np
from collections import Counter
 
def item_coverage(
    all_recommendations: list[list[int]],
    total_items: int,
) -> float:
    """Item coverage@K — katalogun yüzde kaçı önerildi."""
    unique_recommended = set()
    for recs in all_recommendations:
        unique_recommended.update(recs)
    return len(unique_recommended) / total_items
 
 
def user_coverage(
    n_recommended_users: int,
    n_total_users: int,
) -> float:
    """User coverage — yüzde kaç user'a öneri verildi."""
    return n_recommended_users / n_total_users
 
 
def gini_coefficient(items_recommended: list[int]) -> float:
    """
    Gini coefficient — recommendation dağılımının eşitsizliği.
 
    0 = mükemmel eşit (her item aynı sayıda önerildi)
    1 = mükemmel eşitsiz (tüm öneriler tek item'a)
 
    Yüksek gini = popularity bias.
    """
    counts = np.array(sorted(Counter(items_recommended).values()))
    n = len(counts)
    if n == 0:
        return 0.0
    cumcounts = np.cumsum(counts)
    total = cumcounts[-1]
    if total == 0:
        return 0.0
    return (2 * np.sum((np.arange(1, n + 1)) * counts) - (n + 1) * total) / (n * total)
 
 
# Test
import random
random.seed(42)
all_recs = [
    random.sample(range(1, 1001), 10)
    for _ in range(100)
]
print(f"Item coverage: {item_coverage(all_recs, total_items=1000):.4f}")
 
# Toplam recommendation'lar listesi
flat = [item for recs in all_recs for item in recs]
print(f"Gini coefficient: {gini_coefficient(flat):.4f}")
 
# Bias'lı dağılım — popüler item'lar daha çok
biased_flat = (
    [1] * 100 + [2] * 80 + [3] * 60 +  # popüler
    list(range(4, 1004)) * 1            # diğerleri 1 kez
)
print(f"Gini (biased): {gini_coefficient(biased_flat):.4f}")
 

# Intra-List Similarity (ILS)
import numpy as np
from typing import Callable
 
def intra_list_similarity(
    recommended: list[int],
    similarity_fn: Callable[[int, int], float],
) -> float:
    """
    ILS — listedeki item'ların ortalama pairwise similarity'si.
 
    similarity_fn: (item_a, item_b) -> float in [0, 1]
    """
    if len(recommended) < 2:
        return 0.0
 
    n = len(recommended)
    total_sim = 0.0
    count = 0
    for i in range(n):
        for j in range(i + 1, n):
            total_sim += similarity_fn(recommended[i], recommended[j])
            count += 1
    return total_sim / count if count > 0 else 0.0
 
 
def diversity_score(
    recommended: list[int],
    similarity_fn: Callable[[int, int], float],
) -> float:
    """Diversity = 1 - ILS."""
    return 1.0 - intra_list_similarity(recommended, similarity_fn)
 
 
# Test (cosine similarity ile item embedding'leri varsayarak)
np.random.seed(42)
n_items = 100
embeddings = np.random.randn(n_items, 32)
embeddings /= np.linalg.norm(embeddings, axis=1, keepdims=True)  # normalize
 
def cosine_sim(a: int, b: int) -> float:
    return float(np.dot(embeddings[a], embeddings[b]))
 
# Benzer item'lardan oluşan liste — high ILS
similar_list = [0, 1, 2, 3, 4]  # rastgele ama yakın olma garantisi yok
print(f"Random list ILS:    {intra_list_similarity(similar_list, cosine_sim):.4f}")
print(f"Random list div:    {diversity_score(similar_list, cosine_sim):.4f}")
 

# Novelty metrikleri
def user_level_novelty(
    recommended: list[int],
    user_history: set[int],
    k: int,
) -> float:
    """User'ın görmediği item oranı."""
    top_k = recommended[:k]
    new_items = [item for item in top_k if item not in user_history]
    return len(new_items) / k
 
 
def self_information_novelty(
    recommended: list[int],
    item_popularity: dict[int, int],
    total_interactions: int,
    k: int,
) -> float:
    """Self-information (entropy) novelty."""
    top_k = recommended[:k]
    total = 0.0
    for item in top_k:
        pop = item_popularity.get(item, 1)
        prob = pop / total_interactions
        total += -np.log2(prob)
    return total / k
 
 
# Test
recommended = [101, 102, 103, 104, 105]
user_history = {101, 200, 300}
item_pop = {101: 1000, 102: 50, 103: 10, 104: 5, 105: 2}
total = 100_000
 
print(f"User-level novelty:        {user_level_novelty(recommended, user_history, 5):.4f}")
print(f"Self-information novelty:  {self_information_novelty(recommended, item_pop, total, 5):.4f}")
 
# User-level novelty: 0.8000  (101 history'de, 4/5 yeni)
# Self-information novelty: yüksek (çoğu az popüler)