추천 시스템 총정리 (SGD, KNN, ALS)

1️⃣ 잠재요인 기반 협업 필터링 (Matrix Factorization, SVD, SGD)

• 개념:

  • 사용자-아이템 평점 행렬 $R$을 두 개의 저차원 행렬 $P, Q$로 분해
  • $R \approx P \times Q^T$
  • $P$: 사용자 잠재 요인 행렬 ($m \times k$), $Q$: 아이템 잠재 요인 행렬 ($n \times k$)
  • $k$는 잠재 요인의 차원 수 (latent factor)

• 오차 계산:

  $e_{ij} = r_{ij} - (P_i \cdot Q_j^T)$

• SGD 업데이트 수식:

  $P_i \leftarrow P_i + \alpha ( e_{ij} Q_j - \lambda P_i )$
  $Q_j \leftarrow Q_j + \alpha ( e_{ij} P_i - \lambda Q_j )$
  • $\alpha$: 학습률 (learning rate)
  • $\lambda$: 정규화 파라미터 (overfitting 방지)

• RMSE 계산 수식:

  $RMSE = \sqrt{\frac{1}{N} \sum_{(i,j) \in R} (r_{ij} - P_i Q_j^T)^2}$

• 특징:

  • 추천 시스템의 기본적인 모델
  • 희소 행렬에 적용 가능
  • 모델 해석 용이
  • 패턴이 복잡해질수록 딥러닝 대안 필요

• SGD 학습 코드 예제:

for i, j, r in non_zeros:
    eij = r - np.dot(P[i, :], Q[j, :].T)
    P[i,:] += learning_rate * (eij * Q[j,:] - r_lambda * P[i,:])
    Q[j,:] += learning_rate * (eij * P[i,:] - r_lambda * Q[j,:])

• 전체 실행 예시:

P, Q = matrix_factorization(ratings_matrix.values, K=50, steps=200, learning_rate=0.01, r_lambda=0.01)
pred_matrix = np.dot(P, Q.T)
ratings_pred_matrix = pd.DataFrame(pred_matrix, index=ratings_matrix.index, columns=ratings_matrix.columns)

---

2️⃣ 메모리 기반 협업 필터링 (KNN)

• 개념:

  • 사용자 또는 아이템 간 유사도를 기반으로 추천
  • 코사인 유사도(cosine similarity), 피어슨 상관계수 등을 사용
  • 비슷한 이웃 K명을 찾아서 가중 평균으로 평점 예측

• 수식:

  • 사용자 기반 예측:
    $\hat{r}_{u,i} = \frac{\sum_{v \in N(u)} sim(u,v) \cdot r_{v,i}}{\sum_{v \in N(u)} |sim(u,v)|}$
  • 아이템 기반 예측:
    $\hat{r}_{u,i} = \frac{\sum_{j \in N(i)} sim(i,j) \cdot r_{u,j}}{\sum_{j \in N(i)} |sim(i,j)|}$

• 특징:

  • 직관적이며 간단
  • 작은 데이터셋에서 유효
  • Cold start 문제 발생
  • 대규모 데이터에서 비효율적

• 유사도 계산 및 예측 함수 예시:

from sklearn.metrics.pairwise import cosine_similarity
rating_matrix = df.fillna(0).to_numpy()
user_similarity = cosine_similarity(rating_matrix)

def predict_rating(user_index, item_index, k=2):
    sim_scores = user_similarity[user_index]
    neighbor_indices = [i for i in range(len(df)) if not np.isnan(df.iloc[i, item_index]) and i != user_index]
    neighbors = sorted(neighbor_indices, key=lambda i: sim_scores[i], reverse=True)[:k]
    numerator, denominator = 0, 0
    for neighbor in neighbors:
        sim = sim_scores[neighbor]
        rating = df.iloc[neighbor, item_index]
        numerator += sim * rating
        denominator += sim
    return round(numerator / denominator, 2) if denominator != 0 else np.nan

---

3️⃣ ALS (Alternating Least Squares)

• 개념:

  • $P, Q$ 행렬을 번갈아 고정시키고 선형 회귀 문제로 풀어내는 방식
  • 대규모 추천 시스템에서 효과적

• ALS 수식:
  $P = (Q^T Q + \lambda I)^{-1} Q^T R$
  $Q = (P^T P + \lambda I)^{-1} P^T R$

• 원리:

  • $P$ 고정 후 $Q$ 업데이트 → $Q$ 고정 후 $P$ 업데이트를 반복
  • 수렴 속도가 빠르고 병렬 처리에 최적화

• 특징:

  • 대규모 추천 시스템 (예: Netflix, Spark)에서 주로 사용
  • 과적합 방지를 위한 정규화 용이
  • 소규모 데이터에는 비효율적

• SGD와 ALS 비교:

구분	SGD (경사하강법)	ALS (교대 최소제곱법)
업데이트 방식	샘플 단위	블록 단위 (전체 계산)
장점	유연함, 커스터마이징 가능	병렬 처리 및 대규모에 적합
단점	느릴 수 있음	소규모에서 불안정 가능
적용	소규모/커스터마이징 추천	대규모, Spark 기반 추천

• Spark ALS 코드 예시:

from pyspark.ml.recommendation import ALS
als = ALS(userCol="userId", itemCol="movieId", ratingCol="rating", rank=10, maxIter=10, regParam=0.1)
model = als.fit(train)
predictions = model.transform(test)

• Numpy ALS 구현 코드 예시:

for step in range(steps):
    for i in range(num_users):
        for j in range(num_items):
            if R[i, j] > 0:
                error = R[i, j] - np.dot(P[i], Q[j])
                for f in range(k):
                    P[i, f] += lr * (error * Q[j, f] - lambda_ * P[i, f])
                    Q[j, f] += lr * (error * P[i, f] - lambda_ * Q[j, f])

---

✅ 최종 요약

구분	방식	특징	추천 사용처
SGD	벡터 내적 기반 잠재 요인 학습	유연하고 소규모에 적합	커스터마이징, 설명 가능한 추천
KNN	유사도 기반 (메모리 기반)	간단하고 직관적이나 희소/대규모에 한계	소규모, 간단한 추천 시스템
ALS	대규모 최적화 학습	빠르고 병렬 처리에 강함	대규모 서비스, Spark 활용 환경