추천 시스템 개요¶

추천 시스템(Recommender Systems)은 사용자에게 관련성 높은 아이템을 자동으로 제안하는 시스템. 이커머스, 콘텐츠 플랫폼, 소셜 미디어 등 다양한 서비스의 핵심 기술.

핵심 개념¶

데이터 유형¶

유형	예시	특징
Explicit Feedback	평점, 좋아요	명확하지만 희소
Implicit Feedback	클릭, 구매, 시청	풍부하지만 모호
Content	아이템 속성, 텍스트	콜드스타트 해결
Context	시간, 위치, 디바이스	상황 인식

알고리즘 분류 체계¶

Recommender Systems
├── Collaborative Filtering
│   ├── Memory-based
│   │   ├── User-based CF
│   │   └── Item-based CF
│   └── Model-based
│       ├── Matrix Factorization (SVD, NMF)
│       ├── SVD++, BPR
│       └── Neural CF (NCF)
├── Content-based Filtering
│   ├── TF-IDF based
│   └── Embedding based
├── Knowledge-based
│   └── Rule-based, Constraint-based
├── Hybrid Methods
│   ├── Weighted, Switching, Cascade
│   └── Feature Combination
├── Deep Learning
│   ├── Embedding: Word2Vec, Item2Vec
│   ├── Sequential: GRU4Rec, SASRec, BERT4Rec
│   ├── Graph: GCN, LightGCN, NGCF
│   └── Multi-task: MMOE, PLE
├── Reinforcement Learning
│   └── Bandit, DQN for Rec
└── LLM-based (2024)
    ├── LLM as Ranker
    └── Conversational Rec

협업 필터링 (Collaborative Filtering)¶

User-based CF¶

유사 사용자의 평점으로 예측:

\[\hat{r}_{ui} = \bar{r}_u + \frac{\sum_{v \in N(u)} sim(u,v) \cdot (r_{vi} - \bar{r}_v)}{\sum_{v \in N(u)} |sim(u,v)|}\]

Item-based CF¶

유사 아이템의 평점으로 예측:

\[\hat{r}_{ui} = \frac{\sum_{j \in N(i)} sim(i,j) \cdot r_{uj}}{\sum_{j \in N(i)} |sim(i,j)|}\]

Matrix Factorization¶

사용자-아이템 행렬을 저차원 잠재 요인으로 분해:

\[R \approx P \cdot Q^T\]

\[\hat{r}_{ui} = p_u^T q_i = \sum_{k=1}^{K} p_{uk} q_{ik}\]

목적 함수:

\[\min_{P,Q} \sum_{(u,i) \in \mathcal{K}} (r_{ui} - p_u^T q_i)^2 + \lambda(\|p_u\|^2 + \|q_i\|^2)\]

from surprise import SVD, Dataset, Reader
from surprise.model_selection import cross_validate

# 데이터 로드
reader = Reader(rating_scale=(1, 5))
data = Dataset.load_from_df(df[['user_id', 'item_id', 'rating']], reader)

# SVD 모델
model = SVD(n_factors=100, n_epochs=20, lr_all=0.005, reg_all=0.02)
cross_validate(model, data, measures=['RMSE', 'MAE'], cv=5, verbose=True)

# 학습 및 예측
trainset = data.build_full_trainset()
model.fit(trainset)
pred = model.predict(user_id, item_id)

참고 논문: - Koren, Y. et al. (2009). "Matrix Factorization Techniques for Recommender Systems". IEEE Computer.

BPR (Bayesian Personalized Ranking)¶

Implicit feedback을 위한 pairwise 학습:

\[p(>_u | \Theta) = \prod_{(u,i,j) \in D_S} \sigma(\hat{x}_{uij})\]

여기서 $\hat{x}_{uij} = \hat{r}_{ui} - \hat{r}_{uj}$

참고 논문: - Rendle, S. et al. (2009). "BPR: Bayesian Personalized Ranking from Implicit Feedback". UAI.

딥러닝 기반 추천¶

Neural Collaborative Filtering (NCF)¶

MLP로 user-item 상호작용 모델링:

import torch
import torch.nn as nn

class NCF(nn.Module):
    def __init__(self, num_users, num_items, embed_dim=64, mlp_dims=[128, 64, 32]):
        super().__init__()
        self.user_embed = nn.Embedding(num_users, embed_dim)
        self.item_embed = nn.Embedding(num_items, embed_dim)

        layers = []
        input_dim = embed_dim * 2
        for dim in mlp_dims:
            layers.append(nn.Linear(input_dim, dim))
            layers.append(nn.ReLU())
            layers.append(nn.Dropout(0.2))
            input_dim = dim
        layers.append(nn.Linear(input_dim, 1))

        self.mlp = nn.Sequential(*layers)

    def forward(self, user_ids, item_ids):
        user_emb = self.user_embed(user_ids)
        item_emb = self.item_embed(item_ids)
        x = torch.cat([user_emb, item_emb], dim=1)
        return self.mlp(x).squeeze()

참고 논문: - He, X. et al. (2017). "Neural Collaborative Filtering". WWW.

Sequential Recommendation¶

사용자 행동 시퀀스 모델링:

SASRec (Self-Attentive Sequential Recommendation):

Transformer encoder로 시퀀스 패턴 학습:

class SASRec(nn.Module):
    def __init__(self, num_items, embed_dim, num_heads, num_layers, max_len):
        super().__init__()
        self.item_embed = nn.Embedding(num_items + 1, embed_dim, padding_idx=0)
        self.pos_embed = nn.Embedding(max_len, embed_dim)

        encoder_layer = nn.TransformerEncoderLayer(
            d_model=embed_dim, nhead=num_heads, batch_first=True
        )
        self.transformer = nn.TransformerEncoder(encoder_layer, num_layers)

    def forward(self, seq):
        seq_emb = self.item_embed(seq)
        pos = torch.arange(seq.size(1), device=seq.device)
        pos_emb = self.pos_embed(pos)

        x = seq_emb + pos_emb
        mask = (seq == 0)
        output = self.transformer(x, src_key_padding_mask=mask)

        return output[:, -1, :]  # 마지막 위치 표현

참고 논문: - Kang, W.C. & McAuley, J. (2018). "Self-Attentive Sequential Recommendation". ICDM.

Graph Neural Networks¶

LightGCN:

불필요한 비선형 변환 제거, 단순화된 GCN:

\[e_u^{(k+1)} = \sum_{i \in N_u} \frac{1}{\sqrt{|N_u|}\sqrt{|N_i|}} e_i^{(k)}\]

\[e_i^{(k+1)} = \sum_{u \in N_i} \frac{1}{\sqrt{|N_i|}\sqrt{|N_u|}} e_u^{(k)}\]

참고 논문: - He, X. et al. (2020). "LightGCN: Simplifying and Powering Graph Convolution Network for Recommendation". SIGIR.

Two-Tower Model (산업 표준)¶

대규모 추천에서 널리 사용되는 아키텍처:

User Features → User Tower → User Embedding
                                            → Dot Product → Score
Item Features → Item Tower → Item Embedding

장점: - Candidate Generation 단계에서 효율적 - ANN (Approximate Nearest Neighbor) 검색 활용 가능 - 오프라인 아이템 임베딩 캐싱

class TwoTowerModel(nn.Module):
    def __init__(self, user_feature_dim, item_feature_dim, embed_dim):
        super().__init__()
        self.user_tower = nn.Sequential(
            nn.Linear(user_feature_dim, 128),
            nn.ReLU(),
            nn.Linear(128, embed_dim)
        )
        self.item_tower = nn.Sequential(
            nn.Linear(item_feature_dim, 128),
            nn.ReLU(),
            nn.Linear(128, embed_dim)
        )

    def forward(self, user_features, item_features):
        user_emb = self.user_tower(user_features)
        item_emb = self.item_tower(item_features)
        return (user_emb * item_emb).sum(dim=1)

평가 지표¶

정확도 지표¶

지표	수식	의미
Precision@K	$\frac{	\text{추천} \cap \text{관련}
Recall@K	$\frac{	\text{추천} \cap \text{관련}
NDCG@K	$\frac{DCG@K}{IDCG@K}$	순위 고려
Hit Rate@K	$\frac{	\text{관련} \cap \text{추천}
MRR	$\frac{1}{	U

다양성/신선도¶

지표	의미
Coverage	추천된 아이템 다양성
Novelty	인기 아이템 편향 반대
Serendipity	예상치 못한 좋은 추천

실무 고려사항¶

Cold Start 문제¶

유형	해결책
신규 사용자	Content-based, 인기 아이템, 인구통계
신규 아이템	Content-based, 메타데이터 활용

A/B 테스트 지표¶

CTR (Click-Through Rate)
CVR (Conversion Rate)
체류 시간, 시청 완료율
장기 지표: 리텐션, LTV

참고 문헌¶

교과서¶

Ricci, F. et al. (2015). "Recommender Systems Handbook". Springer.
Aggarwal, C.C. (2016). "Recommender Systems: The Textbook". Springer.

핵심 논문¶

Koren, Y. et al. (2009). "Matrix Factorization". IEEE Computer.
He, X. et al. (2017). "NCF". WWW.
Kang, W.C. & McAuley, J. (2018). "SASRec". ICDM.
He, X. et al. (2020). "LightGCN". SIGIR.

라이브러리¶

Surprise: https://surpriselib.com/
LensKit: https://lenskit.org/
RecBole: https://recbole.io/
Merlin (NVIDIA): https://github.com/NVIDIA-Merlin