Similarity Metrikleri: Pearson, Cosine, Adjusted Cosine, Jaccard — Tam Matematik + NumPy

# similarity/metrics.py — 4 similarity metric sıfırdan
import numpy as np
from scipy.sparse import csr_matrix
from typing import Optional
 
 
def cosine_similarity_pair(a: np.ndarray, b: np.ndarray) -> float:
    """Standart cosine similarity — iki dense vektör."""
    norm_a = np.linalg.norm(a)
    norm_b = np.linalg.norm(b)
    if norm_a == 0 or norm_b == 0:
        return 0.0
    return float(np.dot(a, b) / (norm_a * norm_b))
 
 
def pearson_correlation(a: np.ndarray, b: np.ndarray, min_common: int = 2) -> float:
    """
    Pearson correlation — sadece NON-ZERO entries üzerinde.
 
    Recommender mantığı: sadece her iki user'ın da rating verdiği item'lar.
    """
    # Common ratings (her ikisinin de değeri var)
    mask = (a != 0) & (b != 0)
    n_common = mask.sum()
    if n_common < min_common:
        return 0.0
 
    a_common = a[mask]
    b_common = b[mask]
 
    a_mean = a_common.mean()
    b_mean = b_common.mean()
 
    a_centered = a_common - a_mean
    b_centered = b_common - b_mean
 
    numerator = np.sum(a_centered * b_centered)
    denominator = np.sqrt(np.sum(a_centered ** 2) * np.sum(b_centered ** 2))
 
    if denominator == 0:
        return 0.0
    return float(numerator / denominator)
 
 
def adjusted_cosine_item_pair(
    item_i_ratings: dict[int, float],  # {user_id: rating}
    item_j_ratings: dict[int, float],
    user_means: dict[int, float],       # {user_id: avg_rating}
    min_common: int = 2,
) -> float:
    """
    Adjusted cosine for item-item.
 
    User ortalamalarını çıkararak similarity hesaplar.
    """
    common_users = set(item_i_ratings) & set(item_j_ratings)
    if len(common_users) < min_common:
        return 0.0
 
    num = 0.0
    sum_i_sq = 0.0
    sum_j_sq = 0.0
    for u in common_users:
        adj_i = item_i_ratings[u] - user_means[u]
        adj_j = item_j_ratings[u] - user_means[u]
        num += adj_i * adj_j
        sum_i_sq += adj_i ** 2
        sum_j_sq += adj_j ** 2
 
    denom = np.sqrt(sum_i_sq * sum_j_sq)
    if denom == 0:
        return 0.0
    return float(num / denom)
 
 
def jaccard_similarity(a: set, b: set) -> float:
    """Jaccard for binary sets."""
    if not a and not b:
        return 0.0
    return len(a & b) / len(a | b)
 
 
# ====== Vectorized versiyonlar (sparse matrix üstünde) ======
 
def cosine_matrix_vectorized(X: csr_matrix) -> np.ndarray:
    """
    Tüm pair'ler için cosine matrix — O(N²d) ama vectorized.
 
    X: (N, d) sparse matrix
    Returns: (N, N) cosine similarity matrix
    """
    # Row-wise L2 normalize
    norms = np.array(np.sqrt(X.multiply(X).sum(axis=1))).flatten()
    norms[norms == 0] = 1.0
    from scipy.sparse import diags
    X_norm = diags(1.0 / norms) @ X
    # Cosine = X_norm @ X_norm.T (dense output, dikkat memory)
    return np.asarray(X_norm @ X_norm.T.todense())
 
 
# Test
np.random.seed(42)
a = np.array([5, 0, 3, 4, 0, 0])  # user 1 rating'leri
b = np.array([4, 0, 3, 0, 5, 0])  # user 2 rating'leri
 
print(f"Cosine:    {cosine_similarity_pair(a, b):.4f}")
print(f"Pearson:   {pearson_correlation(a, b):.4f}")
# Cosine:  ~0.55
# Pearson: ~0.85   (common items üzerinde sadece, ortalamayla normalize)
 
# Binary test
set_a = {1, 2, 3, 4, 5}
set_b = {3, 4, 5, 6, 7}
print(f"Jaccard:   {jaccard_similarity(set_a, set_b):.4f}")
# Jaccard: 0.4286  (3 ortak / 7 toplam)