이번 시간엔 간단하게 추천시스템을 구현할 수 있는 라이브러리들을 비교해보았습니다. 대부분 베이직한 CF의 Neighborhood model, Matrix Factorization model들이 구현되어있습니다.

Koren의 두 논문 Koren:2008, Koren:2009의 알고리즘을 참고한 경우가 많아서 두 논문과 세미나에서 진행한 두 논문의 리뷰를 참고하시면 좋을 듯 합니다. Koren:2008 리뷰, Koren:2009 리뷰

Implicit

• implicit 데이터에 사용가능한 라이브러리

• 가장 널리 사용된다.

ALS Collaborative filtering

• MF모델. ALS(AlternatingLeastSquares, 교대최대제곱법) 모델.

• 유저행렬과 아이템 행렬을 차례대로 최적화

Baysian Personalized Filtering

• "BPR: Bayesian Personalized Ranking from Implicit Feedback." 논문의 알고리즘.

• 기존의 pointwise 기반의 optimization이 아닌 ranking optimization을 적용함. 논문에서는 MF, neighborhood model 모두 적용한다. 여기선 MF만 구현함. 논문

Logistic Matrix Factorization

• 2014년 Spotify에서 발표한 논문

• LMF는 MF에 logistic함수를 도입하여 item에 대한 user의 선호를 확률적으로 모델링한 것. 논문

Surprise

• explicit 데이터에 사용가능한 라이브러리

Basic algorithms

NormalPredictor

MLE를 통해서 추정한 N(μ^,σ^2)분포를 통해 예측

BaselineOnly

• $\hat{r}{ui} = b{ui} = \mu + b_u + b_i$

user, item 평균치 고려

k-NN inspired algorithms

KNNBasic

• $\hat{r}{ui} = \frac{ \sum\limits{v \in N^k_i(u)} \text{sim}(u, v) \cdot r_{vi}} {\sum\limits_{v \in N^k_i(u)} \text{sim}(u, v)}$

• $\hat{r}{ui} = \frac{ \sum\limits{j \in N^k_u(i)} \text{sim}(i, j) \cdot r_{uj}} {\sum\limits_{j \in N^k_u(i)} \text{sim}(i, j)}$

• basic한 neighborhood model.

• item based, user based 모두 가능

KNNWithMeans

• $\hat{r}{ui} = \mu_u + \frac{ \sum\limits{v \in N^k_i(u)} \text{sim}(u, v) \cdot (r_{vi} - \mu_v)} {\sum\limits_{v \in N^k_i(u)} \text{sim}(u, v)}$

• $\hat{r}{ui} = \mu_i + \frac{ \sum\limits{j \in N^k_u(i)} \text{sim}(i, j) \cdot (r_{uj} - \mu_j)} {\sum\limits_{j \in N^k_u(i)} \text{sim}(i, j)}$

• 각 유저나 아이템의 mean 고려

• basic한 neighborhood model.

• item based, user based 모두 가능

KNNWithZScore

• $\hat{r}{ui} = \mu_u + \sigma_u \frac{ \sum\limits{v \in N^k_i(u)} \text{sim}(u, v) \cdot (r_{vi} - \mu_v) / \sigma_v} {\sum\limits_{v \in N^k_i(u)} \text{sim}(u, v)}$

• $\hat{r}{ui} = \mu_i + \sigma_i \frac{ \sum\limits{j \in N^k_u(i)} \text{sim}(i, j) \cdot (r_{uj} - \mu_j) / \sigma_j} {\sum\limits_{j \in N^k_u(i)} \text{sim}(i, j)}$

• 각 유저나 아이템의 mean, std 고려

• basic한 neighborhood model.

• item based, user based 모두 가능

KNNBaseline

• $\hat{r}{ui} = b{ui} + \frac{ \sum\limits_{v \in N^k_i(u)} \text{sim}(u, v) \cdot (r_{vi} - b_{vi})} {\sum\limits_{v \in N^k_i(u)} \text{sim}(u, v)}$

• $\hat{r}{ui} = b{ui} + \frac{ \sum\limits_{j \in N^k_u(i)} \text{sim}(i, j) \cdot (r_{uj} - b_{uj})} {\sum\limits_{j \in N^k_u(i)} \text{sim}(i, j)}$

• 유저와 아이템의 bias 모두 고려

• basic한 neighborhood model.

• item based, user based 모두 가능

Matrix Factorization(SVD, SVD++, NMF, PMF)

SVD

• bias가 있는 기본적인 SVD 모델.

• 규제항이 있는 squared error를 SGD 한다.

$\hat{r}_{ui} = \mu + b_u + b_i + q_i^Tp_u$

$\sum_{r_{ui} \in R_{train}} \left(r_{ui} - \hat{r}_{ui} \right)^2 + \lambda\left(b_i^2 + b_u^2 + ||q_i||^2 + ||p_u||^2\right)$

biased = False할 시 bias없는 모델 사용가능

SVD++

• $\hat{r}{ui} = \mu + b_u + b_i + q_i^T\left(p_u + |I_u|^{-\frac{1}{2}} \sum{j \in I_u}y_j\right)$

implicit data 사용. SVD와 같이 규제항이 있는 squared error를 SGD 한다.

NMF

• 음수 미포함 행렬 분해(Non-negative Matrix Factorization, NMF)는 음수를 포함하지 않는 행렬 X를 음수를 포함하지 않는 행렬 W와 H의 곱으로 분해하는 알고리즘

• non-negative 데이터는 non-negative feature로 설명하는 것이 좋다는 점, feature들의 독립성을 잘 catch 할 수 있다는 점이 장점 참고

• $\hat{r}_{ui} = q_i^Tp_u$

LightFM

• implicit, explicit 데이터 모두 사용가능.

• LightFM 모델 구현가능

• LightFM은 Collaborative filtering, Content based filtering이 결합된 hybrid model

$q_u = \sum_{j \in f_u}e_j^U$ $p_i = \sum_{j \in f_i}e_j^I$

$b_u = \sum_{j \in f_u}b_j^U$ $b_i = \sum_{j \in f_i}b_j^I$

$\hat{r}_{ui} = sigmoid(q_u \odot p_i + b_u + b_i)$

ex) 아이템이 데님자켓이라면 '데님'과 '자켓'의 latent vector들의 합이 $q_u$, 유저가 미국에 살고 여성이라면 둘의 latent vector의 합이 $p_i$

유저와 아이템 각각의 feature와 둘 간의 상호작용을 모두 고려할 수 있다.

cold start 문제를 완화할 수 있다.

예측 평점이 아웃풋이 아닌 추천 점수가 아웃풋이다. 해당 유저가 해당 아이템을 선호할 확률같은 개념이라고 보면 될 듯하다.

이미지 출처

Buffalo

• 다른 라이브러리에 비해서 적은 메모리 사용과 빠른 속도를 가짐.
• 아래는 ALS 모델에 대한 비교로, Implicit 라이브러리 보다 좋은 성능을 보여준다.

• Alternating Least Squares
• Bayesian Personalized Ranking Matrix Factorization
• Word2Vec
• CoFactors

위의 알고리즘들이 구현되어 있다.

Spotlight

• implicit , explicit 데이터 사용가능

• Factorization models(implicit/explicit), Sequantial models(implicit) 알고리즘이 구현되어 있음

• sequaltial model을 사용가능한 것이 특징

Factorization model

• "dot product of the item and user latent vectors koren's classic matrix factorization" 라고 설명하는 것을 보아 SVD알고리즘인 듯 하다.

$\hat{r}_{ui} = \mu + b_u + b_i + q_i^Tp_u$

$\sum_{r_{ui} \in R_{train}} \left(r_{ui} - \hat{r}_{ui} \right)^2 + \lambda\left(b_i^2 + b_u^2 + ||q_i||^2 + ||p_u||^2\right)$

Sequaltial model

• "Deep Neural Networks for YouTube Recommendations"의 pooling model,

• "SESSION-BASED RECOMMENDATIONS WITH RECURRENT NEURAL NETWORKS"의 LSTM model,

• WaveNet의 causal convolution model

위의 3가지 종류의 모델 존재

참고자료

• Implicit document
• Surprise document
• LightFM document
• Buffalo document
• Spotlight document

https://leehyejin91.github.io/post-bpr/ https://leehyejin91.github.io/post-logistic_mf/ https://greeksharifa.github.io/machine_learning/2020/06/01/LightFM/

paper link

1. Introduction

1.1 Long-tail

이커머스 등 온라인 서비스에서 중요한 롱테일(Long-tail) 법칙 : 80%의 사소한 다수가 20%의 핵심 소수보다 뛰어난 가치를 창출한다. 각 상품들의 총 판매량을 더해보면 인기있는 상품들의 집합이 아닌 긴 꼬리 부분의 합이 더 크다.

• User 관점
  • 인기 아이템(short-head)만 추천하는 것은 유저에게 지루함을 유발할 수 있다.
  • 롱테일 아이템이 유저에게 더 적절할 수 있고 선택에도 다양성을 줄 수 있다.
  • one-stop shopping convenience: 인기아이템과 롱테일아이템을 동시에 구매하도록 유도할 수 있다.
• Business 관점
  • 매출 증진(large marginal profit than short-head items)

1.2 Difficulties in Long-tail SRS

SRS: Session-based Recommendation System

[기존 추천 모델들]

Data sparsity -> popular item에 치우치는 bias 존재

[기존 롱테일 추천 연구]

• 추천의 정확도를 희생시키거나,

(2012) Improving aggregate recommendation diversity using ranking-based techniques (2013) Trading-off among accuracy, similarity, diversity, and long-tail: a graph-based recommendation approach (2017) Enhancing long tail item recommendations using tripartite graphs and Markov process

• data sparsity 문제를 완화하기 위해 SRS의 data limit에서 벗어난 side information(e.g., user profile)을 활용하기도 한다.

(2017) DLTSR: A deep learning framework for recommendation of long-tail web services (2017) Two birds one stone: on both cold-start and long-tail recommendation

[Long-tail SRS 의 3가지 어려움]

1. Lack of side info. in sessions -> 기존 롱테일 추천 방식이 적용되기 어렵다.

2. 기존 롱테일 추천 모델은 sequential한 데이터를 잘 처리하지 못한다. -> 정확도 급락

3. 각 유저의 여러 세션들이 각각 독립으로 처리되기 때문에 상당히 많은 세션 데이터가 sparse하다. 이는 롱테일 추천에서 모델 성능을 악화시킨다.

1.3. TailNet

• SOTA 모델과 비슷한 결과를 내면서 롱테일 추천의 성능 향상
• 각 세션을 latent representation으로 인코딩
• Preference mechanism
  • short-head 아이템과 long-tail 아이템 사이 유저의 선호도를 결정
  • session representation을 학습하고 rectification factors 생성
  • end-to-end로 학습

2. Model

Aim of SRS: 유저의 현재 세션 데이터를 가지고 다음에 클릭할 아이템을 예측

2.1. Notations

$I={i_1, i_2, ..., i_{\vert I \vert}}$ : unique items in all sessions

$I^H$ : short-head items, $I^T$ : long-tail items (Pareto Principle - 2대8 법칙)

$s={i_1, i_2, ...,i_t}$ : 시간순으로 item을 정렬한 session

$V={v_1,v_2,...,v_t}$ : session encoder layer를 통해 인코딩된 session의 latent representation

2.2. GRU Encoder

$s={i_1, i_2, ...,i_t}$ --> $V={v_1,v_2,...,v_t}$

세션 $s$가 인풋으로 들어가면 GRU Encoder를 거쳐 각 아이템별로 $d$차원의 벡터 $v_t$로 이루어진 세션의 latent representation $V$가 나온다.

• GRU Encoder

1. Reset Gate: 이전 시점의 아이템 정보와 현재 시점의 아이템이 인풋으로 들어오며 얼마만큼의 정보를 리셋할지 비율이 결정된다.
2. Update Gate: reset gate와 반대로 얼마만큼의 정보를 업데이트할지 비율이 결정된다.
3. Candidate: reset gate의 아웃풋인 벡터 $r_t$와 이전 시점 정보인 $v_t$를 곱한 결과를 이용하여 현 시점의 정보 후보군을 계산한다.
4. update 결과와 candidate 결과를 결합하여 현재 시점의 아이템 정보를 담은 $v_t$ 벡터를 반환한다.

2.3. Preference Mechanism

: softly adjust the recommendation mode of the model : 유저의 선호도에 따라 long-tail을 더 추천해주거나, short-head를 더 추천해준다.

1. Tail Embedding

$\tau(v_i)$ : i번째 아이템이 long-tail인지 short-head인지 나타내는 mapping function

long-tail=1, short-head=0으로 채워진 input과 동일한 차원의 벡터를 각 아이템 벡터에 더해준다.

2. Attention

$\alpha^m_i$ : i번째 아이템과 마지막 t번째 아이템 사이의 관계를 나타내는 attention weight (scalar)

$S^m_g$ : 각 아이템 별 attention weight를 Tail Embedding을 거친 아이템 벡터에 곱한 ($d$ x $1$) 벡터

3. Linear Transformation

마지막으로 클릭한 아이템의 tail embedding 벡터($TE(v_t)$)와 Attention layer를 거쳐 나온 $S^m_g$ 벡터를 이어붙여 ($2d$ x $1$) 차원의 $W_3$ 가중치 벡터와 선형결합하여 해당 세션의 선호도를 나타내는 점수 $S_p$를 반환한다.

4. Rectification Factors

시그모이드 함수를 이용하여 session preference $S_p$에서 short-head의 rectification factor $R_{head}$ 값을 구하고, long-tail의 rectification factor $R_{tail}$ 값을 구한다.

$R_{head}$와 $R_{tail}$은 후에 Soft Adjustment 단계에서 각각 short-head와 long-tail 아이템 점수들에 곱해지는 가중치로 활용된다.

2.4. Session Pooling and Soft Adjustment

1. Attention

다시 GRU Encoder로 돌아와서 해당 결과로 나온 $V={v_1,v_2,...,v_t}$를 또 다른 Attention layer에 태운다.

Preference Mechanism과 마찬가지로 각 아이템별로 마지막 아이템과의 관계를 나타낸 attention weight (scalar)를 구해 각 시점의 아이템 임베딩 벡터에 곱하여 global embedding 벡터 $S_g$를 생성한다.

마지막 t번째 시점의 아이템이 GRU Encoding을 거쳐 나온 $v_t$를 local embedding 벡터 $S_l$로 둔다.

2. Linear Transformation

$S_l$과 $S_g$를 이어붙인 ($1$ x $2d$)벡터와 ($2d$ x $I$) 차원의 가중치 벡터 $W_4$를 선형결합하여 전체 아이템 개수와 동일한 $I$차원의 $\hat{c}$ 벡터를 반환한다.

$\hat{c}={\hat{c_1},\hat{c_2},...,\hat{c_{\vert I \vert}}}$ :score of corresponding item before softmax

3. Soft Adjustment

Preference mechanism을 통해 구한 rectification factor $R_{head}$와 $R_{tail}$으로 구성된 $I$차원의 벡터 $R={R_{head},R_{tail},...,R_{head}}$를 동일한 차원의 아이템 점수 벡터 $\hat{c}={\hat{c_1},\hat{c_2},...,\hat{c_{\vert I \vert}}}$와 element-wise product 연산을 진행한다.

이를 통해, 각 아이템 점수는 long-tail인지 short-head인지에 따라 해당 가중치가 곱해져 유저가 선호하는 종류의 아이템의 점수가 더 커지도록 한다.

4. Softmax

$(\hat{c} \odot R)$를 softmax layer에 태워 각 아이템이 다음에 올 확률값으로 이루어진 $I$ 차원의 벡터 $\hat{y}$를 반환한다.

이 중 Top-K values들이 다음에 올 아이템으로 추천된다.

5. Cross-Entropy loss

Sum of the cross-entropy of each item's pred. and the ground truth $y$ : one-hot encoding vector of ground truth items

3. Experiments

3.1. Datasets

• YOOCHOOSE: sequences of click events (recent fractions 1/4)

• 30MUSIC: listening and playlists data retrieved from Internet radio stations

3.2. Baseline

Traditional methods

• Frequency based methods : POP, S-POP

• Neighborhood based method: Item-KNN

• Traditional matrix factorization, Markov Chain approaches: FPMC, BPR-MF

Neural network based methods

• RNN-based methods: GRU4REC, NARM

• Repeat-explore method: RepeatNet

• Attention-based method: STAMP

• GNN-based method: SR-GNN

3.3. Evaluation Metrics

[정확도 측정]

Recall@K: 전체 relevant한 아이템 중 추천된 아이템이 속한 비율

MRR@K: (Mean Reciprocal Rank) 사용자가 선호하는 아이템이 리스트 중 어디에 위치해 있는지 평가

[Long-tail 추천 평가]

Coverage@K: 전체 아이템 중 top-K 추천 목록에 있는 고유한 아이템 개수의 비율 $L_K(s)=[i_1,i_2,...,i_K]$ : list of top-K recommended items for session $s$

Tail-Coverage@K: 전체 롱테일 아이템 중 top-K 추천 목록에 있는 고유한 롱테일 아이템 개수의 비율 $L^T_K(s)$ : $L_K(s)$ 중 롱테일 아이템에 속한 아이템으로 이루어진 하위집합

Tail@K: 각 추천 목록에 얼마나 많은 롱테일 아이템이 포함되는지 나타낸 비율

4. Result and Analysis

The performance of TailNet with other baseline methods on two datasets

• 초기 추천 모델들이 정확도 측면에서는 뉴럴넷 기반 추천모델들 보다 성능이 낮지만, long-tail 추천 성능에서는 앞선다.

• 정확도 만으로 추천 모델을 평가하는것은 충분하지 않다.

• Trade-off btw accuracy and long-tail recommendation

• 반면, TailNet은 초기 추천 모델들보다 정확도는 높으면서, 뉴럴넷기반 Sota 모델들보다 높은 long-tail 추천 성능을 낸다.

• balance long-tail recommendations and accurate recommendations

• TailNet은 long-tail 추천에 포커스를 두고 있음에도 불구하고, long-tail와 short-head 아이템 사이 유저의 선호도를 적절하게 파악하여 Preference mechanism이 정확도에 큰 변동을 유발하지 않는다.

• Application of Preference Mechanism in Other Models

  • Preference Mechanism(PM)은 다른 뉴럴넷 기반 모델과도 결합하여 롱테일 추천 성능을 향상시킬 수 있다.
  • 세션의 latent representation만 있으면 PM을 통해 rectification factor $R_{head}$와 $R_{tail}$를 생성할 수 있다.
  • 실제로 attention 계열의 모델 STAMP와 GNN 계열 모델인 SR-GNN에 각각 PM을 적용한 결과, 정확도에 큰 변동 없이 long-tail 성능이 향상되었음을 확인할 수 있다.
  • PM을 통해 뉴럴넷 기반의 모델이 long-tail 추천에서 정보 부족 문제를 극복하는데 도움이 될 수 있다.

Introduction

E-commerce에서의 추천

e-commerce에서 고객들은 최근의 행동이나 기본적으로 가지고 있는 선호와 관련이 없는 구매를 하기도 한다. 예를 들어 6월에 샌들을 사는 고객은 12월에 있는 다음 쇼핑에서 '여름 휴가'와 관련된 아이템을 추천 받고 싶지 않을 것이고, 자신의 취향에 맞지 않은 아이템을 친구의 생일 선물 때문에 구입할 수도 있다.

• Occasion: 구매를 유발하는 특정 시간이나 이벤트
• Global occasion: 크리스마스, 발렌타인데이, 어버이날, 계절(여름에는 서핑 보드를 사고 겨울에는 스노우보드를 사는 것과 같은) → 다수의 유저들에게 유사한 쇼핑 결정을 유도할 수 있다.
• Personal ocacasion: 생일, 기념일 → 일반적으로 특정 유저에 대해 주기적으로 반복적인 패턴으로 발생

Occasion과 쇼핑 행동 사이의 연관성을 활용하여

1. 콜드 스타트 문제를 완화할 수 있다. 여름에는 서핑보드를 추천하고, 겨울에는 스노우보드를 추천 2. Occasion으로 유도된 구매로 인해 유저의 intrinsic preference에 생기는 노이즈를 줄일 수 있다. 다른 사람을 위한 선물 등 Occasion으로 인한 구매는 유저의 일반적인 구매와 비교해 다른 패턴을 보일 수 있으며 이를 파악해 제거 가능 3. 다시 나타날 수 있는 패턴들에 대해 관련 아이템을 추천할 수 있다. 매념 어버이날에 정확히 똑같은 아이템을 구매하지 않을 수 있지만 이전 어버이날에 구매한 물품과 관련이 있을 가능성이 높다.

추천시스템에서 Occasion 신호를 사용하는데 주요 문제

1. 서로 다른 Occasion을 구별하는 패턴을 파악할 수 있는가?
2. 대규모의 crowd behavior를 기반으로 재발하는 쇼핑 트렌드를 포착할 수 있는가?
3. Occasion이 다시 발생하는 시기에 대해 기간을 유연하게 모델링할 수 있는가?
4. 유저의 intrinsic와 특정 Occasion의 영향을 적절히 균형있게 조정한 다음 구매를 정확하게 예측할 수 있는가?

Contributions

1. 쇼핑에 영향을 주는 Occasion의 패턴을 파악하고, 어떻게 유저의 행동을 바꿀 수 있는지 찾아냄.
2. 쇼핑 행동의 temporal trends를 기억하여 global occasion 신호를 모델링하면서 attention layers를 사용해 personal occasion 신호를 모델링한다.
3. Gating component를 사용해 다양한 global effect와 local effect를 균형있게 조정하고, OAR를 제안하면서 각 유저의 intrinsic preference에 초점을 맞춘다.

Motivation

Etsy와 Amazon의 데이터를 사용

Temporal Shopping Trends

아마존 구매 데이터에서는 리뷰에서 언급된 키워드로 유저의 쇼핑 장소나 의도를 대략적으로 추론할 수 있다. → 월별 발생 리뷰를 키워드 기반으로 요약하고 occasion을 파악

• 여름철에는 스웨터 대신 샌들을 많이 구매하고, 꽃무늬 아이템은 봄과 여름에 인기가 많다.
• 어머니의 날이나 크리스마스에 어머니를 위한 구매를 하는 경향이 있다.
• 뿐만 아니라 대규모의 구매가 이루어지는 키워드를 통해 특정 기간의 occasion을 파악할 수 있다.

Occasion Signals for Recommendation

• GMP(General Most Popular)모델: 유저에게 가장 인기있는 항목을 추천하는 간단한 모델
• TMP(Temporary Most Popular)모델: 최근 Time window 내의 인기에 따라 순위를 매김 → time window 5일: 예측하고자 하는 날짜의 앞뒤로 5일. 2018년 1월 10일에 대해 예측하기 위해 지난 11년 동안 1월 5일에서 15일 사이에 가장 많이 구매한 품목의 순의를 매김
• TMP vs GMP*
• 비율이 양수이면(TMP가 GMP보다 더 나은 예측 변수) 강력한, 매년 발생하는 Occasion 기반 쇼핑 추세가 있음을 나타낸다. → 예상대로 크리스마스나 추수감사절과 같은 미국의 큰 명절 즈음에 이런 패턴을 보임. → 비율의 절대값이 다름. 크리스마스의 영향이 발렌타인데이보다 오래 지속됨.
• 반대로 TMP가 GMP보다 성능이 떨어지는 기간도 있다. 이런 경우는 대부분 세계적으로 유명한 Occasion이 없는 시기에 해당한다.
• GMP가 콜드 스타트 문제의 일반적인 해결책이지만 TMP구조가 더 효과적일 수 있다.

Occasion Signals from Personal Perspective

• 개별 유저들에게 다시 발생할 수 있는 occasion: 매년 부모님의 생신 → 이러한 반복되는 occasion은 몇 년에 걸쳐 유사한 쇼핑 행동을 유발할 수 있음. → 이러한 personal occasion들의 패턴과 그것이 추적 가능한지 여부 확인.

• Etsy에서 wedding과 anniversary를 위해 아이템을 구매한 유저 7천여명을 대상으로 time gap 측정하였다.

• 절반 이상의 유저들이 30일 이내에 시차를 두고 원래 wedding과 관련된 구매 시기 근처에 anniversary를 위해 구매하였다. → 다년간 특정 기간(연간 또는 월간)내에 event로 인한 구매가 발생하는 Personal Occasion이 존재

• Infants items 구매가 50% 이상인 유저들의 구매 패턴을 측정한다. → 유아용 제품 구매가 쇼핑에 대한 intrinsic preference라고 볼 수 있다.

• 이러한 유저들은 고유한 선호도에서 벗어난 6월 달에는 아버지의 날과 관련된 아이템을, 1월에는 발렌타인데이를 위해 쇼핑을 하는 경향이 있다. → 이러한 상황은 매년 발생할 수 있으며 매년 유사한 기간에 구매 선호도에 영향을 미칠 수 있다.

• 또한 occasion에 따라 준비 시간이 달라질 수 있다. 유저들은 발렌타인이나 아버지의 날보다 크리스마스를 더 일직 준비하며 쇼핑을 하는 경향이 있다.

• 이러한 간헐적 발생 신호를 포착하고 다시 발생할 상황이 가까워질 때 추천을 조정하는 것이 중요하다.

Occasion-Aware Recommendation(OAR)

Problem Setting

• Set of $N$ users: $U={u_1, u_2, ..., u_N}$
• Set of $C$ products: $P={p_1,p_2,...,p_C}$
• Set of timestamps: $T={t_1, t_2, ..., t_M}$
• User u가 구매한 아이템과 구매한 시간을 pair로 구성: $(p_1^u,t_1^u),(p_2^u,t_2^u),...,(p_n^u,t_n^u)$

⇒ 목표: $t_{n+1}^u$ 시점에 유저 $u$가 구매할 아이템 $p_{n+1}^u$을 예측하여 추천하는 것

Preliminary: Attention Mechanism

• neural attention mechanism은 target query(최근 구입한 항목 또는 예측을 위한 미래의 타임스탬프)와 context contents(구매 이력) 사이의 상관관계를 포착한다.
• 다른 유형의 어텐션 모듈의 입력은 보통 쿼리 및 key-value 쌍의 형태이며, 목표는 출력을 생성하기 위해 일련의 key-value쌍으로 쿼리를 매핑하는 것이다. → 일련의 values를 집계하기 위한 어탠션 가중치로 사용하기 위해 쿼리와 키 사이의 관계/유사성 점수를 계산한다.
• 유저의 고유한 선호도 외에도 다양한 유형의 Occasion 신호를 고려해 유저의 프로파일링을 계산하는 어텐션 메커니즘을 사용할 것을 제안한다.
• RQ1: 유저의 고유한 선호도를 식별하기 위해 최근 구입 항목과 이전 항목 간의 상관관계를 활용하는 방법
• RQ2: 개인의 쇼핑 기록을 추적하여 주기적으로 발생할 수 있는 personal occasion에 대한 유저의 선호도를 모델링하고 예측하는 방법
• RQ3: crowd behavior를 기억하고 관련 global occasion를 파악하기 위해 동적 매핑을 수행하는 방법
• RQ4: 좋은 추천을 위해 유저의 고유한 선호도와 다양한 유형의 occasion들을 어떻게 융합할 수 있는가?

RQ1: Intrinsic Preference Modeling

유저의 고유한 선호도를 식별하기 위해 최근 구입 항목과 이전 항목 간의 상관관계를 활용하는 방법

• 유저의 intrinsic preference는 비교적 안정적이거나 천천히 변화하므로 협업 필터링이나 RNN, CNN으로 모델링하였으며, 최근에는 self-attention을 적용하여 성능이 향상됨.
• 본 논문에서는 최근 구입 항목과 이전 항목 간의 상관관계를 파악하여 intrinsic preference를 파악하고자 한다.

RQ2: Personal Occasion Elicitation

개인의 쇼핑 기록을 추적하여 주기적으로 발생할 수 있는 personal occasion에 대한 유저의 선호도를 모델링하고 예측하는 방법

• 각 유저마다 같은 personal occasion으로 인한 구매는 작은 time window를 가질 가능성이 높다. 예를들어 친구 생일 선물은 생일 2~3주 전에 구입한다.

  → 즉 다음 아이템을 예측할 때 작년, 재작년 이맘 때의 기록이 영향을 준다.

RQ3: Global Occasion Memorization

crowd behavior를 기억하고 관련 global occasion를 파악하기 위해 동적 매핑을 수행하는 방법

• 개인 구매 내역만 추척하면 다가올 global occasion을 예측할 수 없다. 이러한 global occasion은 과거 비슷한 시기의 crowd behavior로부터 포착할 수 있다.

RQ4: Gating Layer

좋은 추천을 위해 유저의 고유한 선호도와 다양한 유형의 occasion들을 어떻게 융합할 수 있는 가?

• 마지막으로 유저의 intrinsic preference와 다양한 occasion 신호의 균형을 맞추는 방법에 대해 논의

• 이전 섹션에서 논의한 각 구성 요소에 서로 다른 가중치를 할당하는 방법을 제어할 수 있는 gating layer 도입

• 타임 스탬프마다 유저의 상태가 다르기 때문에 쿼리는 유저의 시간 스탬프 쌍이 된다.

  → 예를 들어 수공예 용품을 좋아해서 Etsy와 같은 사이트에서 다른 물품을 거의 구입하지 않는 유저들도 있고, 어떤 유저는 12월에는 occasion의 영향을 많이 받지만 6월에는 intrinsic preference를 거의 유지할 수도 있다.

Prediction and Loss

Experiments

Data

• 시간을 기준으로 데이터 split

• Timestamp embedding은 하루를 기준으로 진행

• Etsy: 핸드메이드 제품을 판매하는 최대 e-commerce 플랫폼

  — 2006년 11월부터 2018년 12월까지 구매 데이터 수집

  — 5회 미만 구매 유저는 제거

  — 최근 2년 내에 구매를 한 유저만 포함

  — 첫 구매와 마지막 구매가 1년 이상 차이나는 유저만 포함

• Amazon: 1996년 5월 부터 2014년 7월까지 제품 리뷰를 포함한 데이터 셋 수집

  — 각 리뷰를 구매 기록으로 취급하고 리뷰를 입력하는 시간을 구매 시간의 근사치로 사용

  — 5회 미만 아이템 구매 유저는 제거

Experimental Setup

Metrics MRR@K, NDCG@K Baselines MP, MF-BPR, Fossil, GRU4REC, TCN, HPMN, SASREC

Model Comparison

• MP보다는 MF-BPR이 유저 아이템 간 관계를 파악하기에 성능이 좋다.
• Fossil은 마코브 페인으로 아이템 간 관계를 파악하기에 Etsy에서는 좋지만 Amazon에서는 좋지 않음: 아마존 데이터는 sparse하기 때문에 유저-아이템 간의 interaction을 파악하는 것이 더 중요하다.
• HPMN이 TCN, GRU보다 성능이 좋은데, 해당 데이터셋들이 유저 행동의 주기적인 패턴을 가지고 있기 때문이다.
• self-attention을 사용한 모델의 성능이 가장 좋다.: attention 매커니즘이 sequential behavior를 파악하는데 가장 효과적이다.

Evaluation of OAR

• MP보다 Global occasion만 고려한 모델은 성능이 좋아졌다. Etsy에서 더 큰 향상이 있었다.
• Global 모델은 global occasion만 고려하고, user-specific하게 추천하지 않으므로 성능이 가장 낮다.
• Personal 모델이 Intrinsic보다 조금 더 성능이 좋다. e-commerce에서 유저의 쇼핑 패턴은 개인의 선호도보다 occasion에 더 영향을 받으며 두 모듈을 합하면 성능이 향상된다.
• Gating 레이러를 제거하고, 세개 모듈의 결과 값을 단순합하여 예측한 결과는 OAR에 비해 낮다. 각 유저별로 시간대별로 영향을 받는 정보가 다르기 때문이다.

Case Study

1. Temporal Information and Occasions

• Timestamp 임베딩 간의 유사도 스코어를 계산한 계산 → 가까운 날짜의 임베딩 간의 스코어가 높다.
• 미래의 특정 시점을 예측할 때, 해당 날짜의 과거 기록들 간의 관련이 높다는 것을 의미한다.
• 진한 색이 넓게 퍼지는 것은 occasion의 기간이 긴 경우를 의미한다.
• 1월과 12월을 이어지므로 우측 상단과 좌측 하단이 어둡게 나타난다.
• 2. Visualization of Occasion-driven Purchases in Etsy*
• 모든 유저들에 대해 각 키워드에 대한 아이템 선호도 스코어를 평균하여 그래프를 그렸다.
• 크리스마스 장식과 스카프는 겨울에 구매랑이 많아진다.
• 생일과 같은 카테고리는 flat한 형태를 보인다.
• 3. How Occasion Signals compensate the intrinsic preference*
• 8월 31일에 구매할 아이템을 추천하고자 할때, intrinsic Preference에 따르면 치마와 아기 옷과 관련된 것을 추천하게 된다.
• 그러나 Personal Occasion에 따르면 과거 유사한 날짜인 8월 29일에 구매한 가족의 가방과 관련된 아이템을 추천하게 된다.

작성자: 오진석

ABSTRACT

• Feature engineering 많은 예측 모델에서 중요한 과정 및 역할을 하고 있지만, 복잡하고 직접 하나하나 진행해야 한다는 exhaustive search와 같은 과정을 거쳐야 한다는 단점이 있습니다.

• 딥러닝 모델은 학습하는 과정에 있어, feature 간의 interaction이 implicit하게 반영되기는 하지만 feature cross를 효과적으로 학습하는 것에 있어서는 무리가 있다고 합니다.

• 이번 논문에서는 추천 시스템의 성공적인 성능을 위한 효과적인 feature cross의 학습을 가능하게 해주는 딥러닝 기반의 Deep & Cross Network, DCN 모델을 소개할 예정입니다.

  • feature cross, 특성 교차는 하나 이상의 feature를 조합하여(crossing) 만들어진 합성(synthetic) feature를 의미합니다.
  • feature간 crossing(결합)을 통한 Feature Engineering은 기존의 feature가 개별적으로 줄 수 있는 영향 이상을 주며 예측 성능을 높일 수 있습니다.

• 그러나 보통 모델에 사용되는 feature는 매우 sparse and large하기 때문에, 효과적인 cross를 조합하여 의미있는 feature cross를 찾는 과정은 exhaustive search(완전 탐색)을 요구하게 되며 당연히 비효율적이게 됩니다.

• Deep & Cross Network, DCN은 feature interaction(feature간 상호작용)을 자동적으로 그리고 효율적으로 가능하게 해주는 구조를 제안했었습니다.(2017, Deep & Cross Network for Ad Click Predictions)

  • 그러나 방대한 학습 데이터와 모델 서빙 관점에서 과거 2017년 DCN은 feature interaction을 학습함에 있어 한계점을 보이기도 했습니다.

  • 아직까지도 모델 production 과정에서 많은 DNN 모델들은 여전히 전통적인 feed-forward neural network에 의존하고 있으며, 이는 feature cross에 있어 조금 비효율적이라고 말할 수 있습니다.

• 결론적으로 2020년에 발표된 DCN 논문에서는 방대한 데이터 환경의 large scale에서 적용가능한 DCN-Version 2를 제안하게 되었습니다.

• DCN-V2는 feature interaction을 학습함에 있어 여전히 비효율적인 cost 문제가 남아있기는 하지만 대부분의 대표적인 dataset에서 SOTA의 성능을 보였습니다.

1. INTRODUCTION

• Learning to rank, LTR 은 방대한 데이터와 정보가 넘쳐흐르는 현대에서 정보검색 분야에 있어 굉장히 흥미로운 과제로 발전할 수 있었고 검색 분야, 추천 시스템, 광고 분야에서 머신러닝과 딥러닝이 결합되면서 더욱 광범위하게 발전하고 있는 분야가 되고 있습니다.

  • LTR 모델의 중요한 요소 중 하나는, 효과적인 feature crosses를 통해 수학적으로 그리고 실무적으로 모두 모델의 성능에 기여할 수 있는 것입니다.

• 효과적인 feature crosses는 많은 모델의 높은 성능에 있어 굉장히 중요한 열쇠라고 할 수 있는데, 그 이유는 개별 feature가 모델에 전달하는 영향 이외의 추가적인 상호작용 정보가 포함되어 있기 때문입니다.

  • 예를 들어 'country'와 'language'의 조합은 각 feature가 전달하는 기능 이상의 정보를 전달할 수 있다고 합니다. (한번에 이해가 가지는 않습니다..)

  • 추가적인 예로는, 믹서기를 고객에게 추천하는 모델을 설계하려 할 때, 바나나와 요리책 구매 여부에 대한 각 feature는 개별적인 정보를 전달해줄 수는 있지만 바나나와 요리책 구매 여부에 대한 feature cross는 고객이 믹서기를 구매함에 있어 보다 추가적인 정보를 전달해 줄 수 있습니다.

$$ y = f(x_1, x_2, x_3) = 0.1x_1 + 0.4x_2 + 0.7x_3 + 0.1x_1x_2 + 3.1x_2x_3 + 0.1x_1x_3
$$

출처 : https://www.tensorflow.org/recommenders/examples/dcn

• 선형 모델에서는 보통 hand-craft가 요구되는 feature engineering을 통해 feature crosses를 진행하고 모델의 expressiveness를 확대하게 됩니다.

  • 또한 대부분의 데이터가 categorical한 web-scale applications 상에서는 large and sparse의 특징인 combinatorial search space(수많은 조합)를 수반하기 때문에 exhaustive 합니다.(비효율적, 오래걸리는....)

  • 그렇기 때문에 보통 domain 지식이 요구되고 모델을 generalize 하게 설계하기 굉장히 어렵습니다.

• 시간이 지나면서, 고차원 벡터를 저차원 벡터로 투영하는 임베딩 기술이 발전하게 되면서 다양한 분야에서 일반적으로 사용하게 되었습니다.

• Factorization Machines(FMs)은 2개의 latent vectors(잠재 변수)의 내적을 통해 feature interactions을 뽑아내기도 했습니다.

  • 선형 모델의 전통적인 feature cross와 비교했을 때, FM은 보다 generalize한 성능을 반영했다고 할 수 있었습니다.

• 지난 몇 십년간, 컴퓨팅 파워와 데이터의 폭발적 증가로, 산업에서 LTR 모델은 linear model과 FM-기반 모델에서 딥러닝 모델로 점진적으로 변화하고 있으며, 이러한 변화 및 발전은 추천 시스템과 검색 분야의 전반적인 모델 향상을 일궈냈습니다.

  • 보통 딥러닝 모델은 feature interaction을 찾는 것에 괜찮은 성능을 보이는 것으로 여겨졌지만, 사실 최근 연구를 통해서 단순 딥러닝 모델로는 2nd, 3rd feature cross를 추정하는 것에는 비효율적이라고 밝혀졌습니다.

• 효과적인 feature crosses를 찾기 위한 보다 정확하고 통상적인 해결책으로는 wider하고 deeper한 Network를 통해 model capacity를 증가시키는 것입니다.

  • model capacity가 증가하게 되면 일반적으로 무거운 모델이라고 표현할 수 있으며, 이러한 방법은 모델을 serving하고 production하는 과정에서 문제점이 발견되기 때문에 양날의 검이라고 표현할 수도 있습니다. (무거운 모델이란, 파라미터가 많고 추론하는데 시간이 오래 걸리는 것 등으로 표현할 수 있을 것 같습니다.)

• DCN 또한 wider하고 deeper한 Network를 기반으로 feature cross를 적용하는 것에는 효과적이었지만, large-scale 환경에서의 production 과정에서는 굉장히 많은 어려움을 마주쳤습니다.

• 그래서 2017년에 걸쳐 2020년에 발표한 DCV-V2 에서는 기존 DCN을 개선하게 되었으며, 이미 실험들을 통해 learning to rank 시스템에 성공적으로 배포하였습니다.

  • DCN-V2의 핵심은 cross layer 를 통한 explicit한 feature interaction을 학습하고 deep layer 를 통해 추가적인 implicit한 interaction을 학습함에 있습니다.

2. RELATED WORK

• 최근의 feature interaction을 학습하는 핵심 아이디어는 딥러닝을 통해 explicit, implicit feature crosses를 모두 뽑아내는 것이었습니다.

• explicit crosses를 모델링하기 위해서 대부분의 최근 연구들은 딥러닝에서 비효율적인 multiplicative operations(곱셈)을 제안했으며, feature x1과 x2의 interaction을 효과적이고 명백하게 모델링하기 위해 function f(x1, x2)를 설계하였습니다.

• 다음은 어떻게 explicit, implicit 한 feature crosses를 조합하기 위해 제안했던 연구 방법론들에 대해 알아보겠습니다.

Parallel Structure

• Wide & Deep Model:

Wide 부분은 raw feature의 cross를 입력으로 하고 Deep 부분은 DNN 모델인 Wide & Deep model으로 부터 영감을 얻어 한번에 Parallel(병렬적)으로 학습하는 구조임

• 그러나 Wide 부분을 위한 cross features를 선별하는 과정에서 feature engineering 문제를 만나게 됨

• 그럼에도 불구하고 Wide & Deep model은 이러한 parallel한 구조가 많은 연구에 차용되었고 발전되고 있음

Stacked Structure

• 또 하나의 연구는 explicit한 feature crosses를 뽑아내는 interaction layer를 임베딩 layer와 DNN 모델 중간에 위치되어 있는 stacked(쌓여 있는)으로 학습하는 구조임

• 이 구조는 초반에 feature interaction을 뽑아내고 DNN 모델에서 충분한 학습을 진행하게 됨

3. PROPOSED ARCHITECTURE: DCN-V2

• 이번 목차에서는 explicit, implicit feature interactions를 모두 학습하는 새로운 모델인 DCN-V2의 구조에 대해서 다루게 됩니다.

• DCN-V2는 embedding layer를 시작으로 explicit feature interaction을 뽑아내는 복수의 cross layer를 포함하는 cross network, 그리고 implicit feature interactions를 뽑아내는 deep network로 구성되어 있습니다.

• 기존 DCN에 비해 DCN-V2가 개선된 점은 쉬운 배포를 위해 elegant formula를 유지함에도 불구하고 web-scale production data 관점에서 복잡한 explicit cross를 모델링함으로써 풍부한 표현력을 가지게 되었고 production 과정에 보다 최적화 되어 있다고 합니다.

• cross network와 deep network를 결합하는 방식의 차이로 stacked과 parallel한 2가지 구조가 존재합니다.

3-1. Embedding Layer

• embedding layer에는 categorical과 dense feature가 입력으로 들어가게 됩니다.

• 최종 embedded vector은 categorical features의 임베딩과 dense features의 정규화된 값이 concat되어 출력됩니다.

3-2. Cross Network

• DCN-V2의 핵심은 explicit feature crosses를 뽑아내는 cross layer에 있으며, $x_{l+1}$ layer가 가지는 수식은 다음과 같이 확인할 수 있습니다.

  • $x_{0}$은 기본 feature를 의미하는 embedding layer의 출력 벡터라고 생각할 수 있습니다.

  • $x_{l}, x_{l+1}$은 반복적으로 계산되는 각 layer의 입력 및 출력 벡터를 의미하며 $W_{l}, b_{l}$는 각 layer에서 학습되는 weight와 bias 벡터입니다.

$$ x_{l+1} = x_{0} \odot (W_{l}x_{l} + b_{l}) + x_{l} $$

• 각 layer에서 발생하는 cross layer function을 시각화하여 표현하면 다음과 같이 이해할 수 있습니다.

  • 각 layer의 입력인 $x_{l}$은 똑같이 weight와 bias로 linear 계산이 이뤄지게 된 뒤에, embedding layer의 출력인 $x_{0}$을 element-wise product 해줌으로써 feature간 interaction이 반복적으로 계산됩니다.

  • 첫번째 cross layer의 계산 과정은, $x_{0}$가 linear 계산을 통과한 결과와 $x_{0}$가 element-wise product되면서 update되는 weight가 기존 feature간의 interaction 정보를 담고 있다고 할 수 있습니다.

• 1개의 cross layer가 계산되는 과정을 간단하게 살펴보면, 2nd feature interaction에 대한 정보를 가지고 있는 weight를 확보할 수 있게 되며 weight를 2차원으로 표현하면 다음과 같습니다.

x_0 = [v1, v2, v3] # feature embedding vector

W = [[w11, w12, w13],
     [w21, w22, w23],
     [w31, W32, W33]]

x_1 = [[W11*V1*V1, W12*V1*V2, W13*V1*V3],
       [W21*V2*V1, W22*V2*V2, W23*V2*V3],
       [W31*V3*V1, W32*V3*V2, W33*V3*V3]]

• 해당 heatmap은 첫번째 cross layer가 가지고 있는 weight를 시각화한 것이며, 각 weight가 feature간의 2차원 조합을 기반으로 update됨을 알 수 있습니다.

• 이 때, weight가 더 높을수록 해당 feature 조합이 해당 모델의 결과를 예측하는 것에 있어 강한 상호작용을 의미한다고 해석할 수 있습니다.

3-3. Deep Network

• Deep Network는 전형적인 feed-forward neural network로 다음과 같은 linear 계산과 activation fuction으로 이루어져 있음

$$ h_{l+1} = f(W_{l}h_{l} + b_{l}) $$

3-4. Deep and Cross Combination

• 앞 서 언급했듯이, cross network와 deep network를 결합하는 방식의 차이로 Stacked Structure과 Parallel Structure로 구분할 수 있으며, 데이터에 따라서 성능의 차이를 보인다고 합니다.

• Stacked Structure은 $x_{0}$가 cross network를 통과한 후에 deep network를 통과하는 구조입니다.

  • cross network의 출력값인 $x_{L_c}$가 deep network의 입력값인 $h_0$에 해당합니다.

• Parallel Structure은 $x_{0}$가 동시에 cross network와 deep network에 입력되는 구조로 cross network의 출력인 $x_{L_c}$와 deep network의 출력인 $h_{L_d}$의 결합(concatenate)으로 최종 output layer를 통과하게 됩니다.

• 학습을 위한 손실함수, loss function으로는 binary label의 learning to rank system에서 주로 사용되는 Log Loss를 사용합니다.

$$ loss = - \frac {1}{N} \sum^{N}{i = 1} y{i} log(\hat{y_i}) + (1-y_i)log(1-\hat{y_i}) + \lambda \sum_l ||W_l||^2_2 $$

❗️Log Loss 설명: 출처 - [데이콘 평가산식] log loss에 대해 알아보자, 데이콘

참고 자료

• Deep & Cross Network for Ad Click Predictions, 2017, Ruoxi Wang
• Tensorflow, 심층 및 교차 네트워크 (DCN)
• Dos tacos, Deep & Cross Network for Ad Click Predictions (KR)
• Google-Machine Learning Crash Course, Feature Crosses
• Y.LAB, Learning to Rank와 nDCG
• 알아가는 즐거움, Learning to Rank: 개념만 간단히

1. Introduction and Background

1-1. Conversational Recommendation이란?

추천시스템

추천시스템은 상황에 따른 데이터를 토대로 유저가 원하는 아이템을 찾도록 도와주는 시스템입니다. 최근의 연구들은 유저의 과거 행동을 기반으로 선호도를 예측하거나 일련의 제안을 도출하는 일방향의 one-shot interaction paradigm을 가집니다. 그러나 이러한 접근은 잠재적으로 한계가 있습니다.

Conversational Recommendation

Conversational Recommender System (CRS)는 이와 다르게 접근하여 task-oriented의 지원과 유저와의 multi-turn dialogue를 사용합니다. 이를 통하여 대화 중에 시스템은 유저의 구체적인 현재의 선호도를 알 수 있으며, 아이템 추천에 대하여 설명을 제공하거나, 제안한 추천에 대한 유저의 피드백을 처리할 수 있습니다. CRS는 이렇게 추천시스템에 유저와의 natural language dialogue로 접근하여 개인화된 추천을 제공합니다.

① Task-oriented

CRS의 기본적 특징 중 하나는 task-orientation으로 추천에 관련된 구체적 태스크와 목적을 지원합니다. 이 시스템의 주요 태스크는 유저들의 결정 과정을 돕거나 연관 정보를 찾게 하는 것입니다. 부가적으로 CRS는 유저가 자신의 선호를 알게 하거나 설명을 제공할 수도 있습니다.

② Multi-turn

CRS의 다른 주요 특징은 multi-turn conversational interaction입니다. Siri 같은 기존 one-shot Q&A-style 추천은 multi-turn conversation을 유지하기 어렵지만, CRS는 dialogue state management을 활용하여 대화 내역과 현재 상태를 계속 추적합니다.

1-2. Brief History

CRS에 대한 연구는 매년 그 수가 증가하고 있습니다. 주요 연구로는 1987년 "A New Approach to the Design of Document Retrieval Systems"에서 데이터 수집을 위한 유저와 시스템의 상호작용이 연구되기 시작하였고, 1995년에는 "On the Design of Interactive Information Retrieval Systems"라는 논문이 나오며 script-based한 대화형 상호작용으로 데이터를 수집하고자 했습니다. 마지막으로 2000년에는 "A Conversational Recommendation System"이라는 논문에서 Conversational Recommendation이라는 개념이 등장했습니다. 또한 CRS의 발전은 기술적인 측면과 상업적인 측면 모두에서 유저와 시스템 간에 선순환이라고 합니다.

2. Problem Formalization

2-1. Basic Problem Formalization

다음은 CRS의 기본적인 구성입니다. 입력과 출력이 일반 추천시스템과 비슷한 경향은 있지만, 입력으로 마지막 n개의 발언과 출력으로 다음 발언이 포함된다는 점에서 CRS의 multi-turn 대화라는 차별점을 볼 수 있습니다.

Input

• dialogue history: last n utterances
• (optional) user preferences
• (optional) external knowledge of items

Output

• next utterance
• items recommended to user
• (optional) explanations

2-2. Different Types of Utterances in Conversations

대화에서 발언의 종류는 4가지의 패러다임으로 나뉘어집니다. 가장 위의 SAUP는 시스템이 주도권을 가지고, 밑으로 갈수록 유저가 주도권을 가지게 됩니다. 또한 SAUP에서 SAUA로 갈수록 대화가 더 자연스러워집니다. 여기서는 SAUP, SAUE, SAUA까지만 다루도록 하겠습니다.

System is Active, User is Passive (SAUP)

• 시스템이 유저에게 질문을 하며 대화를 주도
• 유저는 질문에 대답만 할 수 있음

System is Active, User Engages (SAUE)

• 시스템이 질문을 하고 유저는 그에 대답을 함
• 시스템과 유저 모두 chit-chat
• 유저는 대답만 하지 않아도 됨

System is Active, User is Active (SAUA)

• 시스템과 유저 모두 질문을 통해 대화 주도 가능
• 시스템과 유저 모두 chit-chat

User is Active, System is Passive (Voice command, QA)

• 유저가 시스템에 질문을 던지며 대화 주도

Paradigm 1: System is Active, User is Passive (SAUP)

Typical Form: System Ask User Respond (SAUR)

• 시스템이 추천되는 후보를 추리기 위하여 아이템에 대한 질문을 함

Input

• dialogue history

Output

• next utterance = question to ask user
• items recommended to user

Paradigm 2: System is Active, User Engages

Typical Form: SAUR + Chit-chat

• 시스템이 아이템에 대한 질문과 함께 유저와 chit-chat도 함

Input

• dialogue history

Output

• next utterance = question + chit-chat
• items recommended to user

Paradigm 3: System is Active, User is Active (SAUA)

Typical Form: SAUR + Chit-chat + User Ask System Respond

• 유저가 활발하게 질문을 던지고 추천 과정에 참여함

Input

• dialogue history

Output

• next utterance = question or response to user's question
• items recommended to user

2-3. Challenges in Conversation Recommendation

CRS에서 해결해야 할 문제는 크게 5가지입니다. 특히 이 중에서 유저에게 언제 일반적 반응을 하고, 언제 추천을 할지 시점을 판단하는 것이 중요하다고 합니다.

1. How to represent dialogue state?
2. How to represent dialogue action, both user action and system action?
3. How to understand user preference from dialogue
4. When to respond or recommend?
5. What to respond to user?
6. Which items to recommend?

3. Datasets and Evaluation

3-1. Frequently Used Datasets

앞서 언급한 3가지 패러다임에 대하여 자주 이용되는 대화형 데이터셋입니다.

3-2. Evaluation Protocol

Common Evaluation Protocol

다음은 대화형 시스템의 유용성 평가를 위한 접근 방식을 분류한 모습입니다. 왼쪽부터 보자면 Usability Expert는 말 그대로 전문가들을 초대하여 정해진 문항에 따라 평가를 하고, User Participation은 대화 전체에 대한 online evaluation으로 A/B 테스트 등을 포함합니다. 마지막으로 Expert Design Models는 대화에서의 유저 행동을 시뮬레이션하는 방식이며, Calculation은 offline metrics를 사용합니다.

• Offline Evaluation: evaluate on benchmark datsets
• Online Evaluation: evaluate on feedback from real users of the system
• User Study: evaluate based on user's feedback on questionaires
• Simulation-based Evaluation: evaluate based on simulated environments

Evaluation Metrics

CRS의 평가 메트릭은 발언 단위의 Turn-level, 대화 단위의 Dialogue-level, 전체 시행 단위의 Business-level에서의 대화와 추천에 대한 평가로 구성됩니다. 이외에도 둘을 합친 Joint Conversational-Recommendation Evaluation이 있습니다.

1. Evaluation of Conversation Quality: Turn-level, Dialog-level, Business-level
2. Evaluation of Recommendation Quality: Turn-level, Dialog-level, Business-level
3. Join Conversation-Recommendation Evaluation

Evaluation Metrics for Conversation Quality

먼저 대화 자체의 질에 대한 평가 메트릭을 보겠습니다.

Turn-level Metrics

• 시스템이 생성한 문장의 질 자체를 평가 (ex. BLEU, ROUGE, readability)
• 시스템이 생성한 질문 및 또는 응답의 관련성 (ex. accuracy, coverage)
• 대화 행위의 빈도 및 분포 (ex. recommend, ask question, respond)
• 유저 협력

그러나 이러한 turn-level의 척도는 대화의 각 특징만을 평가하므로 대화와 전환율의 일관성을 측정할 수 없다는 한계가 있습니다.

Dialogue-level Metrics

• 대화 길이
• 대화 성공률과 태스크 완료율

Business Metrics

• 세션당 전환율
• 매출
• 그 밖의 유저 만족도 평가, 유저의 유지, 고객 충성도 등

Evaluation Metrics for Recommendation Quality

다음은 얼마나 좋은 추천인지에 대한 평가 메트릭입니다.

Turn-level Metrics

• 각 회당 추천 정확도 (ex. precision, recall, NDCG)
• 추천 행위의 빈도 및 분포

그러나 추천도 마찬가지로 turn-level은 전체 대화의 전반적인 성능을 측정하기는 어렵습니다.

Dialogue-level Metrics

• 한 라운드에서 추천 정확도 (ex. Precision@k, Recall@k, NDCG@k)
• 대화 성공률 (ex. SuccessRate@k)

Business-level Metrics

• 대화당 전환율
• 매출
• 그 밖의 유저 만족도 평가, 유저의 유지, 고객 충성도 등

Evaluation by User Study

User study를 이용한 평가는 유저를 대상으로 usability, bot intelligence, trust, friendliness 등의 항목에 대하여 설문조사를 진행합니다.

4. Conversational Recommendation Methods

4-1. Architectures of Conversational AI Systems

이제 CRS가 어떠한 방식으로 이루어지는지 알아보겠습니다. CRS가 기반을 두는 Conversational AI 시스템은 아래의 그림처럼 크게 3가지 구조가 있습니다.

End-to-End Architecture

먼저 End-to-End Architecture의 경우 문제 해결을 위해 하나의 파이프라인을 하나의 신경망 네트워크로 해결하는 구조를 의미합니다. Sequence2Sequence나 GPT 등의 언어 생성모델을 포함합니다.

Data-Flow Architecture

다음으로 Data-Flow Architecture는 말 그대로 대화 상태를 데이터의 흐름 그래프로 나타내는 구조로, 현재는 연구가 많이 진행되어 있지 않고 미래에 많이 쓰일 수도 있다는 가능성이 있습니다.

Modularized Architecture

마지막으로 Modularized Architecture는 크기, 모양 및 기능적 특징이 유사한 별도의 반복 요소를 표준 단위로 하여 구성된 시스템의 설계 및 사용을 기반으로 합니다. 해당 구조가 실제로 많이 이용된다고 하니, 여기서는 이 Modularized Architecture에 집중해보겠습니다.

CRS를 위한 Modularized Architecture에는 크게 4가지의 모듈이 있습니다.

• Natural Language Understanding/Generation
• Dialogue State Management
• Recommendation
• Explanation

위의 그림을 보시면 CRS는 연결된 기능 모듈로서의 대화형 에이전트가 됩니다. 유저의 query를 받아 NLU를 통해 그 의미를 이해하면, Dialogue State Management에서 현재 취할 행동을 판단하여 추천을 하거나, NLG를 통해 유저와의 상호작용을 지속하여 유저의 반응을 계속 생성합니다. 필요에 따라 추천과 함께 설명을 제공하기도 합니다.

4-2. Natural Language Understanding/Generation

Natural Language Understanding

그럼 CRS에서 NLU, 즉 Natural Language Understanding과 Generation이 어떻게 사용되는지 살펴보도록 하겠습니다. 컴퓨터는 NLP의 첫 번째 주요 컴포넌트인 NLU를 통해 말하는 사람의 말뿐만 아니라 사용자가 실제로 의미하는 바를 추론할 수 있습니다. CRS에서의 NLU는 자유 형식 텍스트 및 모든 유형의 비정형 데이터를 해석하여 맥락을 이해하는 것이 목적입니다. 따라서 CRS에 utterance가 주어졌을 때, 수행해야 하는 태스크는 다음과 같습니다.

• Item Category Detection
• Item Attribute Extraction
• User Intent Extraction
• Slot Value Extraction
• Sentiment Analysis

Natural Language Generation

NLG는 Natural Language Generation으로 머신이 자연어를 출력으로 생성하는 프로세스로 정의할 수 있으며, 이를 어떻게 하면 보다 합리적으로 생성할지 학습시키는 영역입니다. NLG가 텍스트를 생성할 때 몇 가지 어려움이 있습니다. 우선 학습된 데이터를 기반으로 텍스트를 생성하기 때문에 background knowledge가 많아야 하며, 일관성을 유지해야 하고, 유익해야 합니다. 따라서 CRS에서 제안하는 2가지 포맷이 있습니다.

Retrieval-Based

• fluent and informative conversation turns
• less flexible

Generation-Based

• templated-based
• synthesize more flexible and tailored new sentence as reply
• insufficient semantics and informations

대화의 utterance들을 더 통제 가능하게 만들기 위해 template, knowledge, generation을 함께 사용하게 됩니다.

System Ask, User Respond (SAUR)

• Belongs to Paradigm 1 (SAUP)
• Motivation: learn about user preferences on items by asking questions
• NLU: multi-memory network → encode input utterance
• NLG: retrieval-based → select what is most relevant question to ask user

SAUR formalization

u_i: i-th user
Q_0: initial request of a conversation
Q_k: k-th agent question
A_k: k-th user answer
p_k: aspect asked in Q_k
q_k: value answered in A_k
v_j: recommended j-th item

The Unified MMN Architecture

해당 그림은 논문에서 제시된 multi-memory network의 구조입니다. 보시면 Item Representation, Query Representation, Search Module, Question Module을 포함하고 있습니다. 모든 Item Representation이 Search Query와 관련이 있는 것은 아니므로 Attention 메커니즘을 통해 메모리 임베딩을 만듭니다. 이를 통해 모델은 무엇이 중요한 signal인지 알 수 있게 됩니다. 또한 Search Module과 Question Module은 negative sampling을 사용하여 다음 차례에 질문을 더 할지, 최종적으로 아이템을 추천할지 검색합니다.

Advantages of Conversational Recommendation

제시된 그래프는 제안된 모델의 실험 결과로, 왼쪽 그래프는 Hit-Ratio로 평가한 question prediction 태스크, 오른쪽 그래프는 NDCG로 평가한 추천 태스크의 성능 평가 결과입니다. 파란 그래프는 논문에서 제안한 MMN(Multi-memory network)고, 빨간 그래프는 이를 유저 개인화를 위해 살짝 조정한 PMMN(Personalized Multi-memory network)인데 둘 다 좋은 성능을 보여주고 있습니다. 또한 대화가 진행될수록 시스템이 유저의 선호를 더 잘 이해할 수 있다는 것을 알 수 있습니다.

Limitations

그러나 이러한 모델은 언제 질문을 하고 언제 추천을 할지에 대하여 confidence score threshold에 기반한 단순한 방법으로 판단하였고, 유저의 구매 이력이나 클릭 이력 등은 반영되지 않는다는 한계가 있습니다.

Question-based Recommendation (Qrec)

• Belongs to Paradigm 1 (SAUP)
• Motivation: enhance conversation model based on user interactions
• NLU: user response is highly structured, can be easily converted into a vector
• NLG: generate question by slot-filling

Framework of Qrec

Qrec의 구조를 살펴보면 총 5개의 모듈로 구성되어 있습니다. 가장 먼저 Offline initialization module에서 모델은 유저의 과거 평점 데이터를 이용하여 파라미터를 초기화 후 matrix factorization 알고리즘으로 오프라인 학습을 합니다. 다음으로 Continuous updating module은 유저의 답변을 기반으로 하는 closed-form solution를 이용하여 유저와 아이템의 latent factor를 온라인 학습합니다. 그 후, Question learning module은 question pool에서 다음으로 던질 질문 중 가장 적절한 것을 고르는 것을 학습하면 이에 따라 Question asking module에서 대답이 yes/no로 나오는 질문을 유저에게 하게 됩니다. 온라인으로 질문하는 단계가 끝나면 추천 리스트가 생성됩니다.

Evaluation

이는 유저의 과거 평점 데이터를 통해 과거 선호 사항을 반영하며, 리뷰에 있는 아이템의 특성과 메타데이터에 있는 아이템의 특성에 대하여 모두 질문을 하여 아이템에 관한 정보를 포함할 수 있게 되어 더 좋은 성능을 보인다고 합니다.

이는 아마존의 상품 추천 관련 데이터 셋을 다루는 실험 결과인데, 앞서 본 PMMN보다 더 결과가 좋았고, 역시 대화를 더 여러 번 할수록 좋은 성능을 나타냈습니다.

Recommendation through Dialog (ReDial)

• Belongs to Paradigm 2 (SAUE)
• ReDial Dataset
• NLU: hierarchical recurrent encoder-decoder (HRED)
• NLG: switching decoder
• Limitations
  • baseline does not consider user historical behaviors
  • simple dialog management strategy - realized simple softmax function

ReDial Dataset

Proposed method for ReDial Dataset

제안된 모델은 유저와 대화를 하며 영화 취향을 물어보고 그에 적절한 영화를 추천하고자 했습니다. 위의 그림처럼 총 4개의 단계로 구성되어 있습니다.

1. hierarchical encoder following the HRED architecture (Gensen)
2. switching decoder
3. sentiment analysis
4. autoencoder recommender

Limitations

그러나 베이스라인이 유저의 과거 행동을 고려하지 않고, dialogue management가 단순한 softmax라는 한계를 가지고 있습니다.

Multi-Goal driven Conversation Generation (MGCG)

• Belongs to Paradigm 3 (SAUA)
• Motivation: learn strategies to repurpose the conversation to recommendation when the conversation topic drifts
• NLU
  • context-response representation module (C-R Encoder)
  • knowledge representation module (Knowledge Encoder)
• NLG: mixture of retrieval-based and generation-based methods

Goal Planning Module

해당 연구에서는 agent의 응답을 생성하기 위해 goal planning module을 사용합니다. 이 goal planning module은 retrieval-based와 generation-based의 포맷을 함께 이용하는데, 각각의 포맷에서 제공하는 threshold를 기준으로 현재 대화의 목표가 명확한지 판단합니다. 만약 임계치를 넘기지 못한다면 generation-based 포맷이 실행되어 아이템의 특성을 다루는 질문을 계속 하게 되고, 넘긴다면 유저의 취향을 명확하게 하게 되는 질문을 합니다.

4-3. Dialogue State Management

Dialogue State Management는 대화의 상태를 계속 추적하여 다음에 어떠한 행동을 취할지, 예를 들어 질문을 할지 추천을 할지 결정하는 것을 돕습니다. 예를 들어 밑의 그림처럼 호텔을 예약하거나 식당을 예약할 때, 대화가 한 차례씩 진행될 때마다 대화의 상태가 기록이 됩니다. 특히 CRS의 경우에는 질문을 할지 추천을 할지 결정하는 것에 더 집중합니다.

Conversational Recommendation Model (CRM)

• Belongs to Paradigm 1 (SAUP)
• Motivation: learn a model to decide when to recommendation and when to ask
• NLU
  • deep belief track to analyze user's current utterance
  • extract the facet values of the target item
• DSM: RL-based policy network for dialogue state management

Belief Tracker

Belief tracker는 맥락을 기반으로 유저의 현재 발화를 분석하고, 유저 발화에서 타겟 아이템의 facet value를 추출하기 위해 학습됩니다. Belief tracker의 출력은 현재 유저의 의도를 업데이트하는 데에 사용되며, 대상에 대한 facet-value 쌍의 집합으로 표현됩니다.

Policy Network

Policy network는 현재 유저 쿼리와 장기 유저 선호도를 고려하여 각 차례에서 수행할 행동을 결정하기 위해 학습됩니다. 이를 통하여 전체 대화 세션에서의 보상을 극대화하기 위해 유저의 요구를 식별하기 충분할 때 유저에게 개인화 된 항목 목록을 추천하고, 그렇지 않을 경우 추가 정보를 요청합니다.

Limitations

CRM은 몇 가지 한계가 있습니다. 먼저 후보 facet을 5개까지만 지원하기 때문에 아이템 특징의 크기가 큰 경우 확장성이 떨어집니다. 또한 유저가 추천에 대하여 부정적인 피드백을 한 경우 반영이 어렵습니다. 5개의 후보에 대하여 모두 질문했음에도 불구하고 유저가 만족하지 못한 경우에도 추천을 무조건 한 번은 해야하기 때문입니다.

Estimation–Action–Reflection (EAR)

• Belongs to Paradigm 1 (SAUP)
• Motivation
  • What Attributes to ask?
  • When to recommend items?
  • How to adapt to user's online feedback?
• DSM: a policy network that integrates conversational component and recommender component

EAR은 각 발화 차례마다 어떤 특성에 대하여 물어볼지, 언제 아이템을 추천할지, 유저의 피드백을 어떻게 반영할지 다루게 됩니다. EAR은 총 3단계로 구성되어 있습니다. 가장 먼저 estimation 단계에서는 예측 모델을 통해 유저가 선호하는 아이템과 그 특징들을 추정합니다. 다음으로 action 단계에서 dialogue policy를 학습하여, 추정 단계와 대화 기록에 따라 특징에 대하여 더 묻거나 항목을 추천합니다. 마지막 reflection 단계에서는 유저가 추천을 거부할 경우 추천 모델을 업데이트합니다.

Limitations

그러나 이 또한 유저가 자신의 선호도를 명확하게 드러낸다는 가정 하에 이루어지고, 역시 부정적인 피드백은 배제합니다.

4-4. Recommendation

Key Differences from Traditional Recommendation Models

• how to make use of the information encoded in the dialogue?
• how to model the user prefernce dynamically during the dialogue?

Make Use of the Information encoded in the Dialogue

• extract structured information from dialogue
• encode dialogue into continous embeddings

Model the User Preference dynamically during the Dialogue

• update user profile based on the structured information from dialogue
• update user embedding based user profiles and/or continuous dialogue embeddings

Many Recommendation Models can be used based on above Information

• content-based, collaborative filtering, matrix factorization, neural networks, knowledge graph reasoning, graph nerual networks, ...

4-5. Explanation

마지막으로 Explanation 부분입니다. Explanation은 유저가 왜 특정 아이템들이 추천되었는지 알고 있다면 더 나은 질문을 통해 더 나은 대화를 주도할 수 있기 때문에 중요하다고 합니다.

Explainable Conversational Recommendation (ECR)

• Belongs to Paradigm 2 (SAUE)
• Motivation
  • provide explanations to help users understand the recommendation and dialogue
  • collect user feedback from explanations to understand user needs
• NLU: context-aware concept embedding
• NLG: template-based and GRU
  • each round, provide generations from a template based format
• Explanation: constrained explanation generation via bidirectional GRU
  • provide human readable explanations by a constrained generation through bidirectional GRU

Incremental multi-task learning framework

Limitation

그러나 매번 추천을 하기 때문에 DSM이 없으며, 유저가 중립적인 태도는 취하지 않을 것이라 가정하기 때문에 반드시 명백한 피드백을 제공해야만 합니다.

5. Toolkits and Real-world Systems

open source dialogue systems + open source recommender systems

• evison/Conversational
• Dialogue Systems: CMU Olympus, Deeppavlov, Uber Plato, Cisco Mindmeld, Rasa, ...

commercial conversational AI tool kits for developers

• Microsoft Bot framework, Google Dialogflow, Amazon Lex, IBM Watson, ...
• Apple iMessage for business, Facebook messenger bot, ...

commercial all-in-one conversational AI platforms

• Rulai Conversational Computing Platform

References

https://www.youtube.com/watch?v=RdGnJSRA0aw&t=1492s Jannach, Dietmar et al, A Survey on Conversational Recommender Systems, ACM, 2021. Zou, Jie et al, Towards Conversational Search and Recommendation: System Ask, User Respond, SIGIR, 2020. Zhang, Yongfeng et al, Towards Conversational Search and Recommendation: System Ask, User Respond, ACM, 2018. Li, Raymond et al, Towards Deep Conversational Recommendations, NeurIPS, 2018. Liu, Zeming et al, Towards Conversational Recommendation over Multi-Type Dialogs, ACL, 2020. Zhang, Jian-Guo et al, Find or Classify? Dual Strategy for Slot-Value Predictions on Multi-Domain Dialog State Tracking, SEM, 2020. Lei, Wenqaing et al, Estimation-Action-Reflection: Towards Deep Interaction Between Conversational and Recommender Systems, International Conference on Web Search and Data Mining, 2020. Chen, Zhongxia et al, Towards Explainable Conversational Recommendation, IJCAI, 2020.

Abstract

• Contextual Information을 활용하여 Online Personalized recommendation Servies (e.g., 온라인 광고, 뉴스 추천)를 제공하는 방법에 대하여 Contextual Multi-armed banit에 대한 관심이 증가하고 있다.

• 기존의 Contextual Multi-armed bandit은 특정한 context에 대해 arm의 reward를 예측하기 위해 보상 함수의 존재를 가정하는 경우가 많다.

• 하지만 Real-world 에서는 시간이 지남에 User의 선호도가 동적으로 변하는 경우가 많기 때문에 위와 같은 가정은 실제로 적용되는 경우가 거의 없다.

• 논문 저자는 시간에 따라 변화하는 보상 함수에 대하여 Time Varying Contextual Multi armed problem을 연구하였고 특히, Particle learning을 기반으로 한 dynamical context drift model을 제안하였다.

• 제안된 모델은 random walk particles set으로 모델링 되며, fitted particle이 reward function을 학습하도록 한다.

• Particle learning을 통해 모델이 context의 변화를 포착하는데 효과적이며 context의 latent parameters를 학습할 수 있다.

• 온라인 광고와 뉴스 추천에 대하여 제안한 방법론의 효과와 모델이 Time varying reward에 대해서 dynamically tracking 하여 결과적으로 CTR을 향상시킬 수 있다는 것을 보여준다.

[참고]

Multi-armed Bandit problem

Bandits

• MAB는 User가 어느 슬롯머신의 손잡이를 당겨야 가장 높은 수익을 올릴 수 있을지를 결정하는 알고리즘이다.

• MAB에서 가장 중요한 개념은 Exploration(탐색) & Exploitaion(활용)이다.

  • 만약 우리가 꽤 좋은 결과를 돌려주는 기계를 찾아냈다면 좋은 결과를 유지하기 위해 그 기계를 계속 사용할 것인지(exploitation) 아니면 더 좋은 결과를 얻을 거라는 희망으로 다른 기계를 찾아볼 것인가(exploration)?
    • Exploration은 다양한 정보를 수집하기 위해 불확실성이 높은 다양한 광고 콘텐츠를 보여주어 사용자들의 성향을 탐색한다. Exploitation은 사용자들이 많이 소비할 것 같은 광고, 인기 콘텐츠만 제공한다.

  1. Introduction

  ---

• Online Personalized recommender systems은 User와 Item의 현재 정보에 따라 고객에게 적절한 feed(e.g., advertisements, news article)를 주어 고객의 만족을 극대화하려고 한다.

• 이러한 목표 달성을 위해 추천시스템에서 고객의 preferences에 대하여 instantly tracking 과 large item repository에서 흥미로운 아이템을 추천해주는 것이 중요하다.

• Consumer preference와 target items에 대해 적절히 매칭 시키는 것은 어렵다.

  1. Cold Start Problem
  2. 유행의 변화와 고객의 선호도가 dynamically changing

• context-based Exploration-Exploitation tradoff dilemma

  정보를 얻어 가장 좋은 승률을 가진 슬롯머신을 선택해야 하기 때문에 두 과정이 반드시 필요하며, 한 가지 과정을 완전히 배제해서는 원하는 결과를 얻을 수 없다.

• Contextual multi-armed bandit에 대한 여러 알고리즘이 연구됨 ($\epsilon-greedy$, LinUCB, Thompson Sampling) : 이러한 알고리즘들은 동일한 contextual information에서의 reward는 변하지 않는다고 가정한다. 즉, 시간에 따라 변화는 contextual information의 latent factor를 고려하지 않기 때문이다.

동일한 contextual information에 대하여 5개 뉴스의 CTR을 조사하였다. Multi-armed bandit에서는 처음에 많이 선택된 article_1, article_2가 시간이 지나도 CTR이 높을 것이지만 시간이 지날 수록 article_1, article_2에 대한 CTR은 낮아지고 article_3, article_4, article_5에 대한 CTR이 높아지는 것을 확인할 수 있다.

• contextual multi-armed bandit problems의 Time varying reward를 포착 하기 위해 논문 저자들은 Particle Learning에 기반한 Dynamical context drift model을 제안하였고, 효과적인 Onlne 추론 모델을 개발하였다.

• Dynamical Reward에 대하여 random walk particles를 통해 모델링 하였고, Particle learning을 통해 context change와 latent parameters를 학습할 수 있다.

2. Related Work

• 논문에서 Reward의 dynamic한 상황을 해결하기 위한 Contextual Multi-armed bandit을 이용한 context drift model을 제안한다. Latent parameter를 학습하고 Latent States를 추론하기 위해 Sequential Online Method를 개발 하였다.

2.1 Contextual Multi-armed Bandit

• Multi-armed bandit은 다양한 분야에서 사용된다. (e.g., online advertising, web content optimizing, robotic routing)

• Multi-armed bandit의 가장 중요한 목적은 Exploration-Exploitation trade off 의 균형을 맞추는 것이다. 이러한 문제를 해결하기 위해 다양한 algorithms 제안됨 ($\epsilon$-greedy, UCB, EXP3, Thompson sampling)

• Contextual Multi-armed Bandit은 Contextual information을 통해 arm을 선택한다.

• Multi-armed bandit algorithms는 Context information을 통합하도록 확장되었다.

  • $\epsilon-greedy$ : $1-\epsilon$의 확률을 기반으로 Arm을 선택하고 $\epsilon$ 의 확률을 기반으로 random 하게 Arm을 선택한다. 즉, 현재 상황에 대하여 Best arm 선택(Exploitation), 충분한 탐색(exploration)을 위해 $\epsilon$을 선택한다

  • LinUCB, LogUCB : UCB algorithms, 탐색했던 arm으로 부터 얼마나 많은 reward 받았는지 뿐만 아니라 얼마나 확실한지도 함께 따져서, 덜 확실한 쪽에 더 많은 탐색을 하는 방법 , LinUCB는 arm의 reward와 context간에 coefficent vector를 이용하여 Linear Expected Reward를 계산하였다. LogUCB는 Logistic-regression으로 설명

  • Thompson Sampling : earliest heuristics, 각각의 arm에 대한 reward distribution의 parameters를 확률 변수로 보고 이 parameter distribution으로 부터 무작위로 추출하여 해당 값에 대한 reward의 기댓값이 가장 높은 arm을 선택하고, arm에 대한 parameter distribution을 업데이트함 $\rightarrow$ Bandit을 당길 경우를 $\theta_k$ 로 보면, $\theta_k$의 추정값에 대한 prior distribution을 $Beta$분포로 가정하면 conjugacy한 특성으로 인해 posterior distribution을 구할 수 있다.

  • 이외의 최신 연구들은 bootstrap sample와 같이 principled sampling approach하의 parameter-free algorithms을 다루고 있다.

• 하지만 이러한 알고리즘은 동일한 Contextual information하에서 Reward가 변하지 않는다고 가정하고 arm의 expected reward를 예측한다.

2.2 Sequential Online Inference

• Real-world 에서도 효과적인 모델을 위해 저자들은 Sequential Online inference를 사용하여 context의 latent state를 추론하고, model paramters를 학습한다.

  • Sequential Monte Carlo Method (SMC) : filtering problem을 해결하기 위해 제안된 Monte Carlo Method의 set. SMC는 posterior distribution을 계산하는 simulation method를 제공한다. 이러한 방법을 통해 general state space models에서 non-linear and non-Gaussian 일 수도 있는 posterior distribution을 구할 수 있다. (현실 세계의 정보를 반영하는 posterior 구할 수 있다.)

    Filtering problem : 해당 시스템에 대한 불완전하고 잡음이 많은 관측 세트에서 일부 시스템의 실제 값에 대한 "최상의 추정치"를 설정하는 것이다. Monte Carlo Method : Monte-Carlo method는 무작위 추출된 난수(Random Number)를 이용하여 함수의 값을 계산하는 통계학적 방법으로서, 수치적분이나 최적화 등에 널리 쓰인다.

  • Particle Learning : Particle Learning은 general state space models에 대한 sequential parameter learning 및 smoothing인 state filtering을 제안한다. Particle은 광범위한 state space models에 대한 parameter의 불확실성에 비추어 sequential filtering과 smoothing distribution을 통해 근사화 한다. Particle learning의 주요 idea는 resample-propagate framework에서 fixed parameters에 대한 조건부 통계와 particle의 근사를 통해 states에 대한 joint posterior distribution을 직접 샘플링하는 Particle algorithms을 만드는 것이다.

    

• 논문 저자는 Real-world에 대한 latent state inference와 parameter learning을 위해 particle learning 아이디어를 적용하였다.

3. Problem Formulation

• 저자는 Contextual Multi-armed Bandit Problem을 정의하고 Time varying contextual multi-armed badit problem을 정의하였다.

3.1 Basic Concepts and Terminologies

• $\mathcal{A}$ = {$a^{(1)}$,$a^{(2)}$, $a^{(3)}$,$\cdots$ ,$a^{(k)}$} , $k$ = The number of arms $x_{t} \in \mathcal{X}$, $x_t$는 t시점의 contextual information을 의미하고 $\mathcal{X}$는 d차원의 feature space
• Contextual Multi-armed bandit은 유한한 시간 범위 T에 대한 결정
• Policy function $\pi$는 $t \in [1, T]$의 t에 대한 arm을 결정($\pi(x_t)$)한다. arm을 pulling 한 후 policy function에 대한 reward를 받는다.
• t시점의 arm $a^{(k)}$의 reward는 $r_{k,t}$로 표현된다. $r_{k,t}$는 arm $a^{(k)}$에 제시된 context $x_{t}$에 의해 결정되는 미지의 분포로 부터 도출된다. 또한 $a^{(k)}$가 pulling 않으면 reward를 구할 수 없다.
• Total Reward $R_{\pi} = \sum_{t=1}^{T}r_{\pi(x_t)}$ , policy function $\pi$ 가 total reward인 $R_{\pi}$를 최대화 하는것이 목적이다.
• t시점의 arm을 선택하기 전에 policy function $\pi$는 일반적으로 과거 관측치인 $S_{\pi,t-1} = \left {(x_i,\pi(x_i),r_{\pi(x_t)})|1\leq i < t \right }$에 따라 모든 arm에 대한 보상을 예측하는 모델을 학습한다. Reward Prediction은 policy function $\pi$의 결정이 total reward를 증가시키는 것을 도와준다.
• $y_{k,t}$는 arm $a^{(k)}$의 predicted reward, $y_{k,t}$$=f_{a^{(k)}}(x_t)$ 로 표현된다. 즉, contextual information인 $x_{t}$가 reward function $f_{a^{(k)}}$의 input으로 들어간다.

  $f_{a^{(k)}}$의 방법중 하나는 feature vector의 linear combination이다. $ex)$ $f_{a^{(k)}}(x_t)$ = $X_t^{T}W_k + \varepsilon_k$ , $X_t^{T}$는 T 시점의 contextual information이고 $W_K$는 d-dimension의 coefficient vector, $\varepsilon_k \sim \mathcal{N}(0, \sigma^2_k)$, $y_{k,t} \sim \mathcal{N}(X_t^{T}W_k,\sigma^2_k)$

• 이러한 상황에서 Multi-armed bandit은 다음과 같이 표현된다. $X_t$는 t시점의 contextual information, predicted reward인 $y_{k,t}$ 는 random variable $X_t, w_k, \sigma^2_k$에 의해 결정된다.

• random variable인 $w_k, \sigma^2_k$ 의 conjugate prior distribution을 $\mathcal{NIG}$(i.e., Normal Inverse Gamma) distribution으로 가정한다. $\mathcal{NIG}(\mu_w,\sum_w,\alpha,\beta)$, 여기서 parameter들은 predefined함

• policy function $\pi$는 reward prediction model에 따라 arm $a^{(k)}$중 하나를 선택한다. t 시점의 arm $a^{(k)}$를 pulling하면, $r_{k,t}$가 구해진다. 이 후 새로운 sequence $(X_t, \pi(X_t), r_{\pi(X_t)})$ 가 구해져 $S_{\pi, t-1}(X_t, \pi(x_t), r_{k,t})$에 업데이터 되어 $w_k, \sigma^2_k$의 posterior distribution $\mathcal{NIG}$ distribution이 된다. 즉 , t시점의 $w_k, \sigma^2_k$의 posterior distribution이 t+1 시점의 prior distribtuion이 된다.

  Posterior Distribution의 parameter update 과정 :

  • Thompson sampling : each arm $a^{(k)}$에 대하여 $w_k, \sigma^2_k$ 를 $\mathcal{NIG}$로 부터 sampling한 후 , $a^{} = argmax_{1 \leq k \leq K}\left {X_t^TW_k \right }$인, $a^{}$를 선택하고 $r_{a^{*},t}$를 통해 posterior distribution을 update한다.
  • LinUCB : $LinUCB(\lambda)$을 통해 score가 가장큰 arm을 선택한다.

• 이러한 모델의 방법론을 dynamic context drift model에 적용시켰다.

3.2 Dynamic Context Drift Modeling

• arm $a^{(k)}$의 predicted reward는 contextual feature of $X_{t}$와 $W_k$의 linear combination으로 구해진다. 즉 $W_k$의 가중치들은 reward prediction을 하는데 영향을 준다.

• 기존의 방법론은 $W_k$ 가 distribution에 의해 정해진 가중치라고 생각하지만, Real-World에서는 distribution에 대해 알 수없기 때문에 context feature of $X_t$의 predicted reward는 dynamical하게 된다.

• 이에 저자는 dynamic 상황을 고려하여 시간에 따라 변화하는 reward에 대하여 $W_k$ 정보를 포착하기 위해 $W_{k,t}$를 t시점의 arm $a^{(k)}$의 가중치 벡터로 정의한다.

• $\delta_{W_{k,t}}$, 시간에 따라 변화하는 drift weight는 Contextual information의 다양한 특성, context feature의 다양한 scale 때문에 모델링하기 어렵다 (앞에서 설명한 동일한 context상에서의 CTR변화)

• 이에 저자는 추론을 간단화하기 위해 각각의 $\delta_{W_{k,t}}$를 독립적으로 변화한다고 가정한다.

• 불특정한 변환으로 인해 $\delta_{k,t}$를 scale variable $\theta_k$와 Gaussian random walk $\eta_{k,t}$의 element wise product로 표현한다.

• 이러한 모델은 실생활에서 변하는 reward를 고려하여 모델링하였다.

• 새로운 모델에서 $\text c_{\text w_{k}}$ 의 값들은 reward를 prediction하는 feature weight이고 $\theta_k$는 scale of context drifting을 의미한다. $\theta_k$의 값이 클수록 시간이 지남에 따라 feature에서 발생하는 context drifting을 의미한다.

4. Methodology and solution

• Posterior distribution inference는 4개의 random한 변수들에 의해 정해진다. ($\sigma^2_k, \text c_{\text w_k}, \theta_k, \eta_{k,t}$)

• 이러한 4개의 변수들은 parameter random variable와 latent state random variable로 분류된다.

• $\sigma^2_k, \text c_{\text w_k}, \theta_k$는 고정된 parameter random variables고, 시간에 의존적이지 않다.

• $\eta_{k,t}$는 latent state random variable이고 시간에 의존적이다.

• t시점의 context $\text x_t$에 의해 arm $a^{(k)}$의 reward는 $r_{k,t}$로 구해지고 이러한 $X_t, r_{k,t}$는 random variables를 통해 확인될 수 있다.

• 모델의 목표는 latent parameters variables와 latent state random variables를 sequential observed data를 통해 추론하는 것이다. 하지만 latent state radnom variable은 random walk 방법에 의존하기 때문에, 저자는 latent parameters, latent state random의 distribution을 학습하기 위해 Sequential Monte Carlo sampling과 Particle learning을 이용하여 random walk 방법을 사용하였다.

  Standard gaussian random walk를 통한 state $\eta_{k,t-1}$은 시간에 따라 변화하기 때문에 이전 정보들을 통해 구해진 정보를 parameter로 하는 분포에서 뽑아 사용된다. $\eta_{k,t-1} \sim \mathcal N(\mu_{\eta_k},\sum_{\eta_k})$

4.1 Re-sample Particles with Weights

• t-1의 각각의 arm $a^{(k)}$는 고정된 particle size를 가지고 있다. Particle set을 $\mathcal P_{k,t-1}$, Particle set의 개수를 $p$로 생각하면 $\mathcal P^{(i)}_{k,t-1}$은 t-1시점의 arm $a^{(k)}$의 $i^{th}$ particle이 된다.

• 각각의 particle $\mathcal P^{(i)}_{k,t-1}$는 가중치가 있으며 이를 $\rho^{(i)}$로 표현하고 이는 t시점의 새로운 관측 데이터에 대한 적합도를 나타낸다. 즉, $\rho^{(i)}$는 이전 정보들을 통해 $\text x_t$와 t시점의 arm $a^{(k)}$의 reward의 likelihood로 정의된다.

• $y_{k,t}$ predicted value의 distribution은 $\sigma^2_k, \text c_{\text w_k}, \theta_k, \eta_{k,t}$ 를 통해 추정되기 때문에 $y_{k,t}= r_{k,t}$하에서 다음과 같이 $\rho^{(i)}$를 구할 수 있다.

• parameter가 업데이트 되기 전에 resampling먼저 수행된다. weights of particles에 의해$\mathcal P_{k}$에서 generate된 $\mathcal P_{k}'$ 를 통해 sequential parameter가 업데이트 된다.

• 이러한 방식으로 weights of particles의 기반으로 보다 정확한 sampling이 가능해진다.

4.2 Latent State Inference

• t-1시점에서의 $\eta_{k,t-1}$의 충분 통계량은 $\mu_{\eta_k}$와 covariance $\sum_{\eta_k}$ 로 나타난다.

• t시점에서 새로운 $\text x_t$와 $r_{k,t}$이 발생되면 state $\eta_{k,t}$의 충분통계량은 다시 계산되어야 한다. 이때 kalman filtering method를 이용하여 재귀적으로 $\eta_{k,t}$의 충분 통계량을 update한다.

  Kalman Filter : 기존에 인지하고 있던 과거 측정데이터와 새로운 측정데이터를 사용하여 데이터에 포함된 노이즈를 제서키셔 새로운 결과를 추정하는데 사용하는 알고리즘으로 선형적 움직임을 갖는 대상을 재귀적으로 동작시킨다.

• 이를 통해 $\eta_{k,t}$는 다음과 같은 분포에서 추출된다.

4.3 Parameter Inference

• t-1시점의 parameter random variable( $\sigma^2_k, \text c_{\text w_k}, \theta_k$)의 충분 통계량은($\alpha, \beta, \mu_c, \sum_c, \mu_{\theta}, \sum_{\theta}$)이다.
• $\text z_t, \mu, \nu$는 2d-dimensional vector이고 $\sum$은 2d x 2d - dimesional matrix 그러므로 $\text c_{\text w_k}$, $\theta_k$를 추론하는 것은 $\nu_k$를 추론하는 것과 같다.

4.4 Intergration with Policies

• 3.1에서 LinUCB와 Tomson sampling은 $\text w_k, \sigma^2_k$가 posterior distribution에 의해 samplig된다.

• t 시점의 $\text x_t$에 대해서 arm $a^{(k)}$ 가 pulling되지 않았기 때문에 Context drifting model은 reward $r_{k,t}$를 모른다. 즉, t시점의 k번째 arm에 대한 reward가 없으면 t시점의 particle re-sampling, latent state inference, parameter inference가 samppling되지 않는다.

• 또한 모든 arm은 독립적인 p개의 particle을 가지고 있어서 각각의 particle에서 $\text w_{k,t-1}$의 posterior distribution을 이용할 수 없다. 왜냐면 현재까지 아는 정보는 $\text w_{k,t-2}$의 posterior distribution을 t-1시점의 prior distribution이 되기 때문이다.

• 이에 저자들은 Tompson smapling과 LinUCB가 weight sampling을 한 방법을 적용하여 다음과 같이 정의를 하였다.

• $\text w^{(i)}{k,t-1} , \mu^{(i)}{\text w_k}, \sigma^{2^{(i)}}k, \sum^{(i)}{\text w_k}$를 $i^{(th)}$ particle의 random variables로 생각해보면 $\text w_{k,t-1}$을 $\bar{\text w}_{k,t-1}$로 정의할 수 있다. (bandit algorithm에서의 추론 방법)

  4.5 Algorithm

  

  5.EMPIRICAL STUDY

  ---

• 저자는 모델을 성능을 확인하기 위해 2개의 real-world dataset을 사용하여 실험하였다. (the online search advertising data from Track2 of KDD CUP 2012, news recommendation data of Yahoo ! Today News)

  5.1 Baseline Algorithms

• Random, $\epsilon-greedy$ , GenUCB($\lambda$), TS($q_0$), TSNR($q_0$), Bootstrap, Our Methods : TVUCB($\lambda$), TVTP($q_0$)

  5.2 KDD Cup 2012 Online Advertising

• USER (age, gender)와 search engine(query keywords, some ads information about click count on ads)의 interaction 데이터

• 저자들은 binary feature vector of dimension 1,070,866 사용, 1 million user visit events

• Bandit problem evalution을 위해서는 simulation, replayer 방법이 있는데, large number of Recommending items (> 50) 에서는 simulation 방법이 적절 하였다.

5.3 Yahoo ! Today News

• news data collection < 50 , replayer 방법 사용

5.4 Time Cost

6. Conclusions

• 저자는 dynamic behavior of reward을 위한 context drift model을 제안하였다.

• Particle learning을 통해 parameters와 latent drift of the context을 효율적으로 학습하는 model을 제안하였다.

• 기존에 존재하는 Bandit algoritms를 개선하여 보다 contextual dynamics한 상황 tracking을 가능하게 하였으며 CTR에 대하여 personalized recommendation performance를 향상 시켰다.

Pinterest + GraphSage = PinSage

Ying, Rex, et al. Proceedings of the 24th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining. 2018. 907 citations.

Hamilton, William L., Rex Ying, and Jure Leskovec. "Inductive representation learning on large graphs." 31st Conference on Neural Information Processing Systems (NIPS 2017). 3378 citations.

해당 논문에서 제안한 모델인 PinSage에 대해 알아봅시다.

Chapter 19, CS224W

Overview

PinSage는 실제 서비스 되고 있는 핀터레스트(Pinterest)에 적용된 추천알고리즘으로, 학습에 쓰인 데이터는 pin과 board로 구성된 3 bililon 노드와 18 bilion 엣지를 가지고 있습니다.

PinSage는 GCN 모델로, 그래프 데이터에 랜덤 워크(randowm walks)와 graph convolution을 적용한 방법론입니다.

추천시스템에 적용하기 위해서는 효율적인 연산이 중요하기 때문에, GCN 모델을 서빙하기 위한 여러가지 방법을 제안하였습니다.

Introduction

당시에 GCNs(Graph Convolutional Networks)은 추천시스템을 포함한 다양한 분야에 적용되면서 많은 발전이 되었습니다. GCN의 핵심은 이웃들(neighbohoods)로부터 특징 정보를 반복적으로 모으는(aggregate) 방법을 학습하는 것입니다. 이때, convolution이라고 불리는 연산을 사용하여 one-hop 이웃들의 정보를 변형하고(transform) 모으게(aggregate) 됩니다. 이 one-hop convolution layer를 여러 개 쌓음으로써 이웃의 정보를 계속적으로 변형하고 모으기 때문에, 멀리 떨어진 이웃들의 정보까지 닿을 수 있습니다. 기존의 content based RNN 모델과는 다르게, GCN은 contents 뿐만 아니라 그래프 구조까지 활용합니다.

그러나, GCN-based 모델은 scailability가 떨어지기 때문에, 수십억 개의 노드와 엣지를 가지며 시간에 따라 변하는 추천 데이터에 적용하는 것이 매우 어렵습니다.

해당 논문에서는 높은 scailability를 가지고 있는 random walk기반 GCN 모델을 제안하였습니다.

PinSage를 요약하자면 다음과 같습니다.

Scailability

• On-the-fly convolution (Transductive vs. Inductive) 기존 GCN은 full-graph에서 연산을 진행한 반면, PinSage는 target node를 선정한 뒤 이웃을 sampling하는 방식(computation graph를 생성)으로 진행합니다. 따라서 전체 그래프에 해당하는 연산을 필요로 하는 GCN의 단점을 완화시켰습니다.

• Producer-consumer minibatch construction Producer와 consumer의 역할을 CPU와 GPU로 나누어 진행하였습니다. CPU를 computation graph 생성을 위한 sampling을 진행하고, GPU는 생성된 computation graph로 모델 학습을 진행합니다.

• Efficient MapReduce inference MapReduce와 같은 파이프라인을 설계하여 반복적인 연산을 최소화하면서 빠르게 임베딩 벡터를 생성할 수 있습니다.

New techniques

• Constructing convolutions via random walks 효율적인 연산을 위해 computation graph를 미리 생성한다고 하였습니다. 이때, 무작위하기 이웃을 생성하는 것은 비효율적이기 때문에, short random walk를 사용합니다.

• Importance pooling Random walk를 활용해 노드들끼리 유사성(similarity)을 구할 수 있습니다. 해당 논문에서는 이 유사성을 importance score로 정의하였으며, 이를 aggretation과 pooling 단계에 사용하여 가중(weighted)연산을 하였고, 46% 성능 증가를 가져왔습니다.

Figure 1: Overview of our model architecture using depth-2 convolutions

• Curriculum training 학습을 진행할 때마다 좀 더 어려운 예시를 모델에 보여줌(curriculum traning)으로써, 12%의 성능 증가를 가져왔습니다.

Method

PinSage의 구조, 학습 방식, MapRudece pipleline에 대해 살펴보겠습니다.

• Node: item (pin and board)
• Feature: visual, textual feature

Problem setup

Pinterest의 contents인 pin은 유저의 주 관심사이며, board는 pin의 collections입니다. 해당 추천시스템은 이러한 pins를 잘 임베딩하고자 하는 것입니다. 임베딩을 위해 그래프를 정의해야 하는데, 여기서는 pin의 집합 $I$ 와 board의 집합 $C$을 이분 그래프(bipartite graph)로 생성하였습니다.

Bipartite graph, Chapter 19, CS224W

Notations $I$: set of items $C$: user-defined contexts $u \in I$: pin/item $x_u \in \mathbb{R}^d$: real-valued attributes (content information, i.e., text and image feature)

Goal bipartite graph와 node feature $x_u$를 활용하여 node embedding을 수행함.

Model Architecture

Localized convolution

Step 1: $z_v, \forall v \in \mathcal{N}(u)$를 linear layer로 변형함. Step 2: aggregation/pooling $\gamma$ 적용하여 $n_u$ 벡터 생성함. Step 3: 노드의 벡터 $z_u$와 aggregation된 이웃 벡터 $n_u$를 concatenate, linear layer로 변형함. Step 4: nomalization

Inportance-based neighborhoods(Importance pooling) PinSage에서 핵심인 inportance score에 대해 살펴봅시다. 기존의 GCN과 다르게, PinSage는 타겟 노드에게 상대적으로 많은 영향을 주는 노드들을 선별하여 aggregate/pooling을 진행하였습니다.

Step 1: 타겟 노드 $u$에서 random walk를 시작함. Step 2: random walk로 방문한 노드들의 방문 횟수를 계산함. Step 3: 타겟 노드 $u$의 이웃들 중에서 이전 스텝에서 계산한 값 상위 T개를 선출함.

해당 밥법은 두 가지 관점에서 이점을 가져옵니다.

• 메모리를 줄일 수 있다.
• 중요한 이웃들만 고려하여 노드를 업데이트 시킬 수 있다.

또한 Step 2에서 계산한 값을 $L_1$ normarlization을 하여 aggregate/pooling의 weight으로 사용하였습니다.

Stacking convolutions 하나의 Convolution layer 파라미터는 $Q, q, W, w$가 있으며, node들끼리 공유하게 됩니다. Algorithm2는 minibatch에 어떻게 convolution layers를 적용하는 지 보여줍니다.

Convolution이 끝난 후 생성된 target node의 representation은 linear layers를 한 번 더 거치게 되고, 최종 output embedding이 만들어지게 됩니다.

모델 파라미터 정리: 각 convolution layer의 weight과 bias: $Q, q, W, w$ 마지막 linear layer: $G_1,G_2, g$

Model Training

PinSage는 max-margin ranking loss를 학습에 사용하며, item pair인 $(q,i)\in \mathcal{L}$을 가깝도록 임베딩하게 됩니다.

수십억 개의 embedding을 학습하기 위해 어떻게 효율적으로 연산을 했는지 살펴보도록 하겠습니다.

Loss function Basic idea: postive pair의 내적을 최대로 만들고, negative pair의 내적값을 미리 정의한 margin $\Delta$만큼 거리를 유지하게 만들자.

, where $P_n(q)$은 negative sample의 분포입니다.

Multi-GPU training with large minibatches Producer-consumer minibatch constructions

Sampling negative items PinSage는 학습의 효율을 개선하기 위해 500개의 negative sample을 minibatch마다 공유할 수 있도록 하였습니다. 해당 논문에서는 두 가지의 sampling 방법을 제안하였습니다.

• 무작위 샘플링 (unifonly sample) 전체 아이템세트에서 무작위로 negative item을 뽑는 것으로, postive와 negative를 구분하기 매우 쉽다.
• Hard negative sampling "hard" negative item을 negative sample로 정하여 학습시키 방법으로, positive sample은 아니지만, 상대적으로 가까운 negative sample을 뽑는 방법이다. Personalized PageRank score(C. Eksombatchai, et al.(2018))를 활용하여 item의 score를 결정하게 되고, 2000-5000위 사이의 ranked item을 뽑게 된다.

논문에서는 hard negative sample을 학습에 사용하면, 수렴을 위해 2배의 epoch이 요구된다고 하였습니다. 이를 해결하기 위해, 처음부터 har sample을 사용하는 것이 아닌, 학습을 진행할수록 hard negative sample을 하나씩 추가하는 curriculum training을 적용하였습니다.

Figure 2: Random negative examples and hard negative examples

Node Embeddings vis MapReduce

모델 학습이 끝난 후에, 학습 데이터의 모든 아이템과 그 외의 아이템을 임베딩하는 것은 계산적으로 매우 어려운 일입니다. 따라서 해당 논문에서는 MapReduce approach를 개발하였으며, 반복적인 계산을 줄여 효율적인 연산이 가능하도록 하였습니다.

Figure 3: Node embedding data flow to compute the first layer representation using MapReduce

Experiments

평가를 위해 두 가지 태스크를 진행하였습니다.

• Recommending related pins Related pin을 추천하기 위해 임베딩 공간에서 k nearest neighbor를 선택합니다.

• Recommending pins in a user's home/news feed Pin을 추천하기 위해, 유저가 가장 최근에 추가한 아이템과 임베딩 공간에서 가장 가까운 아이템을 추천합니다.

Chapter 19, CS224W

Feature used for learning 각각의 pin은 text(title)과 image 데이터와 관련되어 있습니다. 따라서 visual embedding(VGG-16, $d=4096$), textual embedding (Word2Vec, $d=256$)를 concatenate하여 node feature를 생성합니다.

Baselines for comparison

• Visual embedding: 이미지 임베딩 공간에서 nearest neighbor 사용
• Annotation embedding: annotation 임베딩 공간에서 nearest neighbor 사용
• Combined embedding: visual + annotation 벡터에 2-layer multi-layer 모델을 사용
• Graph-based method: random-walk-based 방법을 사용하여 타겟 pin의 top K 이웃을 추천

Table 1: Hit-rate and MRR for PinSage and content-based deep learning baselines

Conclusion

• 해당 논문은 random-walk graph convolutional network를 활용한 PinSage라는 모델을 제안하였습니다.
• PinSage는 기존의 GCN 모델이 가지고 있던 scailability의 한계를 극복하기 위해 inductive setting과 MapReduce와 같은 알고리즘을 활용하였습니다.
• 실제 성능과 효율성을 측정하기 위해 A/B test를 진행하였고, 좋은 결과를 보여주었습니다.

작성자 : 이혜린, 장아연

0. ABSTRUCT

Event recommendation은 Cold Start 문제를 직면해왔습니다. 이러한 한계를 극복하기 위해 논문에서는 Event-based social network(EBSNs)에서 RSVPs로 사용자에서 파생된 collaborative signals와 event의 description 기반의 Content Based Signal 이외로 Contextual Signal에 해당하는 social signals, location signals, temporal signals을 수집합니다. 최종적으로 다음의 signals을 조합해 event에 대해 learn to rank를 진행해 Personalized Recommedation을 제시합니다.

1. Introduction

1) Cold Start

많은 양의 가능성이 있는 Event는 때때로 User가 그들의 흥미에 딱 맞는 event를 찾는 것을 방해하기도 합니다. 이런 과도한 정보량에서 Recommender system이 관련있는 정보를 제시해 준다는 점에서 문제 상황을 극복하는 솔루션이라고 생각되기도 하지만, 책과 영화 같은 classic한 Recommender scenarios와 달리 event recommender는 새로운 event에 대해 Cold Start 문제를 가집니다. EBSNs의 Event의 다음과 같은 특성 때문에 Cold Start 발생이 불가피하다고 할 수 있습니다.

• 주로 short lived
• always in future

즉, EBSNs의 Event는 이전의 과거 행적과 연관성이 매우 적어 전통적인 Recommender approach로는 EBSN User에게 만족감을 주기 어렵습니다.

2) Contextual Signal 수집

RSVPs (불어로 "Please Respond"라는 뜻의 문장의 약어)로 사용자에서 파생된 collaborative signals와 event의 description 기반의 Content Based Signal 이외 Contextual Signal을 도입함. 수집한 Contextual Signal에는 다음과 같은 것들이 있습니다.

• social signals : group memberships 기반
• location signals : users’ geographical preferences : user의 home과 각 event 발생지까지 거리 기반
• temporal signals : users’ time preferences 기반

이런 Contextual signal은 User의 Event 참석 여부 결정을 추정하는데 도움이 될 것이라고 가정합니다.

3) 더 정확한 Recommender System을 위한 Contributions

• EBSNs에서 발생 가능한 multiple contextual signal을 바탕으로 specialized된 event recommendation model들 비교
• learning to rank event를 위한 feature로서 multiple context-aware recommendation model 이용해 hybrid recommendation approach 제안
• state of the art recommender와 대조하며 효율성을 비교하고 Meetup.com 크롤링 한 것을 통해 철저하게 approach 평가

2. Problem Setting

1) Cold Start Problem

전통적인 recommendation system은 주로 2개의 entity 간의 interaction에 대한 modeling이 진행됨. 그러나 Context-aware recommender는 interaction을 정의하는데 도움이 되는 additional signal까지 사용함. EBNS에서 Additional Signal 사용이 불가피한 이유는 다음과 같습니다.

• Event는 항상 미래에 발생되기 때문에 EBNS에서의 User와 후보가 되는 Event 사이의 interaction 없음
• User-Event attendance의 경향성에 대한 RSVP의 data를 사용해도 여전히 대부분의 event에 대한 정보가 누락됨

따라서 이런 Cold Start 문제를 해결하기 위해 EBNS에서 풍부한 contextual evidence를 이용하기를 제안합니다.

2) Major Problem : Which of available events are more likely to be attended by user?

결국 이 논문에서는 주어진 target user와 contextual signal을 이용해 다음의 문제를 해결하기 위해 다음과 같이 formalizing problem setting 진행합니다.

• RSVP data를 time-stamp $\theta$ 전후를 기준으로 분할
  • training partition: $\theta$ 전으로 발생한 (user, event) 쌍
  • test partition: $\theta$ 후로 발생한 (user, event) 쌍
• $U$ : the set of users
• $E$ : the set of events
• $T$ : contextual signals users’ temporal preferences
• $G$ : set of groups that users can join
• $D$ : users’ geographic distance preferences
• $C$ : the textual content of events

Implicit data : content, User, time, event, group, distance 간의 relation : Task : find scoring function : 후보 Event에 대한 preference score 배정 Top -n recommendation :

• $n$ : number of events to be recommended
• $E_{u}$ : 과거 User가 참석했던 Event의 set

Minimize a ranking loss function :

• 위 함수는 $\hat{s}$ $\in$ $\mathbb{R}^{E}$ 에 의해 생성된 추천리스트와 training할 동안 실제 event에 대해 무지 상태였던 test user에 대한 $\mathcal{P}$의 부분 집합으로서 actual list 사이에서의 misfit을 측정합니다.

Context-aware recommender의 Relevance Score :

• Context - Aware recommender가 context $X$에서 $u$$\in$$U$와 $e$$\in$$E$ 간의 Relevence score를 계산한 것을 다음과 같이 표현했습니다.

3.Contextual Model

1) Social-Aware

EBNS에서 User는 다른 User와 online/offline으로 만나며 interaction을 가짐. 따라서 두가지의 소통 형태에 대해 각각 Model을 제안합니다.

a. Group Frequency Model

User가 Group에서 더 많은 Event에 참여할수록, 계속해서 해당 group의 event에 참여할 가능성은 높습니다.

Target User $u$ $\in$ $U$에 대해 해당 Event의 Relevance Score

• $g_{e}$ : 후보 event $e$와 연관된 group
• $E_{u}$ : User $u$가 참여한 모든 event 집합
• $E_{u,g_{e}}$ : Group $G$ $\in$ $g_{e}$에 의해서 형성된 event 중 User u가 참석한 모든 event
• $S_{1}$ : 이 recommender가 표현하는 social context

b. Multi-Relational Model

Group Frequency Model에서는 다음의 2가지 관계가 고려되지 않았습니다.

• User와 그들과 친밀한 모든 group간의 관계
• Group과 그 Group에서 진행된 Event

User가 친밀하게 여기는 group과 동일/유사한 group에 의해 진행되는 event는 참여할 가능성이 높기 때문에 다음의 관계는 반드시 고려되어야하고 더 나아가 추천 시스템에서의 cold start 문제를 해결할 수 있습니다.

본 논문의 저자는 Multi-Relational Factorization with Bayesian Personalized Ranking (MRBPR)을 이용해 위의 interaction을 모델링합니다.

Target Relation $R_{UG}$ $\subseteq$ $U$ X $G$와 $R_{GE}$ $\subseteq$ $G$ X $E$의 친밀한 관계를 포함한 joint factorization approach를 진행합니다.

Parameter

• 각 고려하는 entity와 관련된 $U$, $E$, $G$의 latent matrices 즉, user 집합인 $U$는 $U$$\in$ $\mathbb{R}^{|U|* k}$ 와 관련되어 있습니다. ($k$ : 고려 대상이 되는 entity에 대한 latent factor의 갯수)

Objective Function

• $L$ : Loss Function
• $\alpha$, $\beta$, $\gamma$ : 고려하고 있는 relation에 대한 weight
• $\lambda_{U}$, $\lambda_{G}$, $\lambda_{E}$ : regularization parameter

Stochastic Gradient Descent SGD를 통한 parameter learning이 이루어집니다.

Predict Relevance score

• $\vec{u}$ : user $u$에 대한 latent vector
• $\vec{e}$ : event $u$에 대한 latent vector

기존의 single relation에서 이루어진 standard matrix factorization과 다른 점은 latent factor인 $u$와 $e$ 모두 user가 미래의 event 참여 여부 결정에 영향을 미치는 group aspect을 포함합니다.

2) Content-Aware

Content base filtering이 EBNS에서 유망한 접근법인 이유는 다음과 같음.

• 유사한 특징을 보이는 event 찾아냅니다.
• 유사한 context 속에서 발생한 event에 대한 recurrent event를 찾습니다.

event에 대한 text 설명은 classic bag-of-words model이 진행됩니다. 과거 user가 참석했던 event에서 뽑아낸 단어 대한 TF-IDF vector는 각 user를 대표합니다. 각 event는 추천 인스턴스에 대해 time distance로 weighted됩니다. (Time value of money decay function : a measure of the rate of decline in the value of an events contract due to the passage of time과 비슷한 맥락)

Profile of target user

• $\vec{e}$ : event description에서 나온 term에 대한 TF-IDF 표현
• $\alpha$ : time decay factor
• $\tau(e)$ : 추천하는 순간과 event $e$에 대한 RSVP 사이 날짜

Rank Candiate Event

각 user의 입장에서 Cosine similarity를 바탕으로 한 후보 event에 대한 순위 제시하고 있습니다.

3) Location-Aware

한 도시 내에서 유저의 이동 패턴은 모두 다양합니다.

• User1 : 한 지역 내에 이벤트가 집중되어 있고, 다른 지역에서는 때때로 발생
• User2 : 2개의 지역에 이벤트가 집중되어 있음

이처럼 이벤트의 발생 패턴은 공간적 정보에 따라 상이하다는 것을 확인할 수 있으며, 이를 추천을 위한 하나의 feature로 사용하기 위해 저자는 다음과 같은 approach를 제안합니다.

Kernel-based density estimation approach

Kernel-based density estimation을 통해 유저의 이동패턴을 발생한 이벤트 간의 기하학적 거리의 분포로 모델링하고자 합니다. 이는 새로운 이벤트는 유저가 과거에 일으켰던 이벤트들의 지역들 중 하나에서 발생할 가능성(aggregated likelihood)을 바탕으로 발생하기 때문입니다.

$L_{u}$ 가 unknown distribution $f$를 따른다고 할 때, kernel density function $\hat{f}$ 은 다음과 같이 정의됩니다.

• $L_{u} = \bigcup_{e\in E_{u}}l_{e}$
  • $L_{u}$ : 타겟 유저가 과거에 참가했던 이벤트들의 위경도 sample
  • $l_{e}$ : 이벤트 $e\in E_{u}$ 의 위경도
• $K_{H}(·)$ : Bivariate Gaussian Kernel
  • $K_{H}(X) = {1 \over \sqrt{2\pi \vert H \vert}}\epsilon^{-{XX^{T} \over 2\sqrt{H}}}$
  • $H$ : bandwidth를 표현하는 행렬

유저의 지리적 선호도는 $l_{e}$에 centered된 가우시안 분포의 합으로 표현됩니다.
후보 이벤트들은 과거에 타겟유저가 참여했던 이벤트들과의 거리를 바탕으로 평가되며, 그것을 수식으로 표현한 결과는 다음과 같습니다.

4) Time-Aware

유저가 A이벤트에 참여할지를 결정하는 중요한 요인 중 하나는 이벤트가 언제 발생하는지입니다. 논문의 저자들은 유저들이 선호하는 특정 요일, 혹은 특정 시간대가 존재할 것이라고 가정합니다.

위 그림에서 첫번째 유저는 매일, 그리고 주로 밤에 이벤트가 발생했으며 두번째 유저는 일주일 중 2번, 그리고 오직 오후에 이벤트가 발생한 것을 알 수 있습니다.

이 인사이트를 공식화하기 위해, 각각의 이벤트 $e$를 24x7-dimension 벡터인 $\vec{e}$로 표현합니다.

• $\vec{e}$는 일주일 동안의 매 시간들을 의미하기 때문에 특정한 날, 특정한 시간에 이벤트가 발생한다면 해당 위치의 원소는 1의 값을 갖게 됩니다.
• 따라서, 각각의 유저는 그들이 과거에 참가했던 이벤트들을 centroid $\vec{u}$로 표현하게 됩니다.

마지막으로 유저 $u$와 이벤트 $e$ 간의 score는 두 벡터의 코사인 값으로 표현됩니다.

5) Learning to Rank Events with Contextual Features

Event recommender의 효율성을 높이기 위해 (특히 cold start), 앞서 생성한 recommenders($=s$)를 이벤트의 순위를 매기기 위한 학습의 feature로 사용합니다.

• $\mathcal{D} = { (x_{1},y_{1}), ..., (x_{n}, y_{n}) }$
• $x_{i} = (\hat{s_{1}}(u,e), ..., \hat{s_{m}}(u,e), \vert U_{e} \vert )$
  • training set
  • $\hat{s}$ : user $u$와 과거에 발생했던 이벤트 $e$ 사이에서 생성된 정규스코어($z-value$)로 구성된 feature vector
  • $\vert U_{e} \vert$ : 이벤트의 sparsity
• $y_{i} = {0,1}$
  • 유저 $u$가 이벤트 $e$에 참석했으면 1, 아니면 0
  • rank setting 학습을 위해, classes are ordinal (i.e. 0 < 1)

    Multi-Contextual Learning to Rank Events (MCLRE)

    그리고 다음과 같은 학습 인스턴스 $(x_{i}, y_{i}), (x_{j}, y_{j})$ 의 관계를 반영할 수 있게끔 $h(x)$를 학습시킵니다. $h(x)$는 최종 추천 리스트를 생성해내는 함수이며, 이 method가 MCLRE 입니다.

또한 $h(x)$는 Coordinate Ascent방식으로 학습되었습니다.

Coordinate Ascent

• rank approach mathod
• 타겟 랭킹 평가 metric을 직접적으로 최적화
• NDCG@10을 평가 metric으로 사용

위 그림은 coordinate descent에 관한 그림입니다. coordinate descent가 목적함수를 minimize하는 방식이라면, 위 논문에서는 metric인 $NDCG@10$를(높을수록 좋은 metric) maximize하는 방식으로 훈련을 시킨다고 생각하시면 될 것 같습니다. 또한 coordinate descent는 gradient descent와 굉장히 유사해 보이지만, gradient descent는 학습 과정에서 한번에 모든 파라미터를 update한다면 coordinate descent(ascent)는 한번에 하나의 파라미터를 update하는 방법이라는 차이가 있습니다.

4. Evaluation

1) Experimental

a) Event dataset

• Meetup.com 데이터 크롤링
• Meetup : 내 주변 이벤트 찾기
  • 나의 관심사에 맞는 이벤트를 추천받고, 참가하도록 연결해주는 서비스
  • 매우 Sparse한 데이터셋 (sparse data 비율이 99.99% 이상)

b) Evaluation Protocol

• sliding training window 이용
• Timestamp 기준 이전 6개월 데이터 : Training
• Timestamp 기준 이후 6개월 데이터 : Test (해당 유저의 이벤트 발생여부를 예측하기 위한 데이터로 사용됨)
  

c) Recommendation Baseline

• MP : Positive response(yes) 순으로 정렬한 뒤 상위 10개 선택

• BPR-MF : Bayesian Personalized Ranking (with Matrix Factorization) / 사후 확률 최대화

• BPR-NET : BPR-MF 모델의 regularization term으로 2개의 social network를 사용 (the social network from the shared groups of users, the social network inferred from the co-attended events)

2) Results

Q1. How effective is MCLRE for event recommendation?

baseline 모델과 비교했을 때 MCLRE의 성능이 모든 지역(chicago, phoenix, san jose)에서 좋습니다.

Q2. How robust is MCLRE to sparsity in the RSVP data?

baseline 모델들은 sparsity level이 높아질수록 NDCG@10이 감소하는 편에 속하나, MCLRE는 event sparsity와 user sparsity 모두에서 꾸준히 좋은 성능을 보여줄 수 있음을 알 수 있습니다.

Q3. Which contextual features are effective recommenders?

• $MP$ : Positive response(yes) 순으로 정렬한 뒤 상위 10개 선택
• $T$ : contextual signals users’ temporal preferences
• $D$ : users’ geographicdistance preferences
• $C$ : the textual content of events
• $S1$ : the social context represented by Group Frequency Model (in Social-Aware)
• $S2$ : the social context represented by Multi-Relational Model (in Social-Aware)
• $MCLRE$ : Context feature를 함수 $h(x_{i})$를 통해 결합하여 사용한 모델

우리의 MCLRE 모델의 성능이 가장 좋았습니다.

5. Related Works

(생략)

6. Conclusions and Outlook

본 논문은 여러개의 context-aware recommender를 input feature로 사용하는 Rank Approach를 학습시키는 Event Recommendation Problem을 다뤘습니다.

각 사건들에 대한 설명을 바탕으로 한 content-based signal과 RSVP에서 비롯된 collaborative signal로부터 social, geographic, 그리고 temporal signal들을 도출했습니다.

또한 NDCG@10을 직접적으로 최적화함으로써 각각의 context-aware recommender의 output score로부터 개별적인 랭킹을 학습하는 랭킹 알고리즘인 Coordinate Ascent를 사용했습니다.

본 모델을 Meet-up.com 데이터를 통해 평가했을 때, 성능이 향상되었음을 알 수 있었습니다.

저자들은 향후 다음과 같은 태스크를 추가적으로 실행할 것이라고 얘기하며 논문을 마무리 합니다.

• 본 논문의 경우 미국이라는 한 나라에 있는 여러 도시에 대해 실험을 진행했는데, 다양한 나라에 있는 여러 도시에 대해 본 과정을 반복할 예정
• 다른 contexts와 접근법을 탐구할 예정
• 페이스북 이벤트 같은 다른 종류의 Event-based Social Networks에 대해서도 연구할 예정

참고 문헌

• https://dl.acm.org/doi/pdf/10.1145/2792838.2800187
• https://www.investopedia.com/terms/t/timedecay.asp
• https://soobarkbar.tistory.com/147

1. INTRODUCTION

!

2. RELATED WORK

해당 논문의 Related work에서는 word를 Embedding하는 NLP모델의 계속된 향상과 context 속에서 word의 의미를 파악해 vectorization하는 것에서 나아가 다양한 분야에 확장/적용 가능하다는 점을 시사함. 이에 따라 간략하게 NLP 모델의 구조와 NLP 모델의 발전 에 대해 살펴봄.

3. METHODOLOGY

4. EXPERIMENTS

5. CONCLUSION

참고 자료

• Mihajlo Grbovic & Haibin Cheng. (2018). Real – time Personalization using Embedding for Search Ranking at Airbnb. KDD

• https://brunch.co.kr/@andrewhwan/54#comment

• https://medium.com/mighty-data-science-bootcamp/airbnb-listing-embeddings-in-search-ranking-d0f39116fc44

• https://papers.nips.cc/paper/2013/file/9aa42b31882ec039965f3c4923ce901b-Paper.pdf

• https://lovit.github.io/nlp/representation/2018/03/26/word_doc_embedding

• https://wooono.tistory.com/244

Abstract

• 기존의 방법론은 낮은 차원의 상호관계(low-order interactions)나 높은 차원의 상호관계(High-order interactions)에 치우쳐 학습을 하거나, 전문가의 feature engineering이 필요하다.

• 논문 저자는 낮은 차원(low-order), 고차원(high-order)의 feature interactions을 End-to-End 모델로 학습할 수 있음을 보여준다.

• DeepFM은 Factorization machines이 가지는 장점과 Deep Learning이 가지는 장점을 결합한 새로운 Neural Network 구조이다.

[참고]

• ** CTR (Click-Through Rate) 이란 **

  클릭률(CTR)은 광고를 본 사용자가 해당 광고를 클릭하는 빈도의 비율입니다. 클릭률(CTR)을 사용하면 키워드와 광고, 무료 제품 목록의 실적을 파악할 수 있습니다.(클릭수 ÷ 노출수 = CTR) -Google Ads

• Factorization Machines :

Linear Regression : 유저와 아이템에 대한 평가를 예측하는 문제라고 생각하면 추천시스템은 선형 회귀식에서 시작 되었다.

*Polynomial Model *: 추천 시스템의 데이터는 categorical type 변수가 많고 one-hot-encoding 값이 많아 데이터의 차원이 크고 Sparse하다. 이를 위해 각 변수 간의 interaction을 고려한 모델이 제안되었다.

이러한 모델링은 Linear Regression의 한계를 극복 가능 하지만 Parameter 수가 증가 하기 때문에 연산이 복잡, Factorization Machines는 feature interaction vector를 저차원으로 factorize하여 이를 해결함

*Factorization Machines *: Polynomial model에서 interaction weight인 $w_{ij}$ 가 두 벡터 $(\vec{v_{i}} \cdot \vec{v_{j}})$의 내적으로 factorize 되었다. 이 두 벡터는 interaction의 latent vector로 표현함으로써 latent space내에서 interaction을 보다 더 잘 잡아낼 수 있다.

Introduction

Click-Through Rate Prediction for recommendation

• The task of predicting the likelihood that something to website(such as an advisement) will be checked
  
  

• CTR Prediction은 User가 추천 아이템을 클릭할 확률을 추정하는 것으로 유저에게 추천될 아이템의 순위를 매길 수 있다. 또한 온라인 광고 같은 시나리오에서도 수입을 증가시킬 수 있다. $\Rightarrow$ CTR을 정확하게 추정하는 것이 핵심이다.
  
  

• CTR Prediction은 User click 행동에 존재하는 implicit feature interactions를 학습하는 것이 중요하다.
  
  

• 일반적으로 User click 행동의 interactions는 매우 복잡하고 low-order, high-order interaction이 중요한 역할을 한다.

  Example

  1. 식사시간에 배달앱 다운로드 하는 경우 많음 -> "app category"와 "time-stamp"의 interaction (order-2)
  2. 10대 남자들은 Shooting games & RPG games 좋아함 -> "app category"와 "gender", "age"의 interaction (order-3)
  3. Association rule에 의해 발견된 '기저기와 맥주'의 interaction (order-2)

• 예시 1,2 와 같이 쉽게 어떠한 feature interactions는 쉽게 이해할 수 있지만, 대부분의 feature interactions는 데이터 속에 숨겨 있고 prior 정보 만으로 알기 어려워 machine learning에 의해 auto-matically하게 포착되어야 한다.(예시 3)

  Previous Approaches

• Generalized Linear Model FTRL [McMahan et al. 2013] :

  선형 모델은 feature interaction을 학습하기에 부족하며 pairwise feature interactions을 직접 feature vector로 넣어준다.

  이러한 방법은 High-order feature interactions 학습하기 어렵고 cold start 문제가 존재함.

• Factorization Machine (FM) [Rendle, 2010] :

  pairwise feature interactions을 feature 간의 inner product를 통해 모델링 하였다.

  High-order feature interaction을 모델링 할 수 있지만 High Complexity로 인해 order-2 feature interaction만 고려한다.

• Factorization-machine supported Neural Network_ (FNN) [Zhang et al., 2016]_ :

  Deep Neural Network에 적용하기 전에 FM으로 pre-trains 하여 feature embeddings의 가중치를 초기화 하여 학습을 한다.

  DNN에 적용하기 전에 FM을 pre-train 하기 때문에 FM에 의해 성능이 제한된다.

• Product-based Neural Network (PNN) [Qu et al., 2016] :

  Feature interactions에 대해 Embedding layer와 fully-connected 사이에 product layer를 도입하였다.

  FNN과 PNN은 다른 DNN 처럼 CTR Prediction에 필수적인 low-order feature interactions를 거의 포착하지 못한다.

• Wide & Deep learning for Recommender Systems (Wide & Deep) [Cheng et al., 2016] :

  low order & high-order interactions를 모델링하기 위해 linear("wide") model과 DNN ("deep") 을 결합한 Wide & Deep 모델을 제시하였다.

  Wide & Deep은 두 개의 다른 input(wide part, deep part)을 필요로 하는데 wide part input은 feature engineering이 필요함

  wide part input은 designed pairwise feature interaction이기 때문에 입력 vector가 굉장히 커져 Complexity를 증가시킨다.

Problem

• low-order or high-order feature interaction, feature engineering을 모델링 하는데 치우쳐 저 있다.

• feature engineering 없이 low order, high-order feature interactions를 End-to-End 방식의 모델을 제안함

Model Structure

• Factorization Machines(FM)과 Deep Neural Network(DNN)의 구조를 결합한 새로운 NN모델인 DeepFM을 제시한다.

• Wide & Deep 모델과 다르게 같은 input, embedding layer를 공유하기 때문에 효율적으로 학습할 수 있다.

• Benchmark data와 commercial data에 평가한 결과 다른 CTR Prediction 모델 보다 일관적으로 향상된 결과를 보였다.

Our Approach

Traning Dataset

$x=[x_{field_{1}},x_{field_{2}},\cdots,x_{field_{j}},\cdots, x_{field_{m}}]$

$y=\left{ \begin{matrix} 1 & user; clicked; the; item \ 0 & {otherwise} \end{matrix} \right .$

• n개의 $(\chi, y)$ 데이터가 구성되어 있다. $\chi$는 User, Item pair m-fields 구성되어 있다.

  $\chi$ Categorical fields (e.g., gender, location): one-hot encoding Continuous fields (e.g., age) : value, Discretization & one-hot encoding

• CTR Prediction 모델의 목적은 context가 주어졌을 때 특정 앱을 클릭할 확률을 추정하는 모델을 만드는 것이다.

  

  DeepFM

  

  • DeepFM은 같은 input을 통해 FM Component(low-order feature interaction)와 Deep Component(high-order feature interaction)을 학습하는 것을 목표로 한다.

• FM Component와 Deep Componet가 같은 Embedding 벡터를 공유한다. 이러한 구조는 두 가지 장점을 가진다. 1) $Field; vector$의 크기가 다를 수 있지만 $Embedding ,Layer$로 인해 같은 크기(k=5)를 가진다.

  Gender의 경우 크기가 2인 $V_{gender}$ 이지만 국적이나 나이의 경우 Gender보다 더 큰 벡터를 가지게 된다. 하지만 결과적으로 $k-dimension$으로 Embedding된다.

  2) (FNN) [Zhang et al., 2016] 에서는 $V$ 가 FM에 의해 pre-trained 한 feature embeddings의 가중치를 초기화하여 학습하지만 DeepFM은 pre-trained할 필요가 없고 End-to-End로 학습을 할 수 있게 된다.

• 결과적으로 $\hat{y}$는 FM, DNN의 예측값의 합을 $sigmoid$를 적용한다.

  FM Component

  

  • FM Component는 (FNN) [Zhang et al., 2016] 에서 제안된 feature interaction을 학습하기 위한 Factorization machines 이다.

• FM은 각각 feature latent vector의 inner product (order-2)로 feature interaction을 모델링한다.

• FM의 Output은 Addition Unit과 Inner Product Unit의 합으로 다음과 같이 표현된다.

  

Deep Component

• Deep Component는 high-order feature interaction을 학습하기 위한 Feed-Forward Neural Network이다.

• CTR prediction 모델의 Input data는 굉장히 Sparse하고 super high-demensional하다. $\Rightarrow Embedding layer$를 통해 Input vector를 low-order dense한 vector로 압축되어 NN에 입력된다.

  

Relationshop with the other Neural Networks

• FNN [Zhang et al., 2016] : feature embeddings의 가중치를 FM에 의해 pre-trained 값을 initialization하기 때문에 두 가지 제한점을 가진다.

  1) Embedding 파라미터가 FM의 영향을 받을 수 있다.

  2) Pre_trained에서 도입된 Overhead로 효율성이 저하된다.

  High-order feature interaction은 학습할 수 있지만 low order feature interaction은 학습 불가능 하다 DeepFM의 경우 사전 훈련이 불 필요하며, low & high order feature interaction 학습 가능하다.

• PNN [Qu et al., 2016] : High order feature interaction을 포착하기 위해 $Embedding, Layer$와 $First; Hidden ; Layer$ 사이에 $Product$를 추가한 모델이다. $IPNN$(내적), $OPNN$(외적), $PNN$(내적 ,외적)

  계산을 효율적으로 하기 위해 $IP$(내적)을 할 경우 뉴런을 제거하고 $OP$(외적)을 할 때 차원을 압축하여 근사적으로 계산한다.

  1) $IP$(내적)을 할 경우 reliable하지만 $Product,Layer$이후에 $Hidden,Layer$의 모든 neuron에 연결도기 때문에 High Computational Complexity가 요구된다.

  2) $OP$(외적)을 할 경우 unstable하고 feature의 정보를 잃어 버린다.

  3) 저차원 feature interaction이 무시된다.

  DeepFM의 FM Component는 마지막 $Output, Layer(1; neuron)$에만 연결된다.

• Wide & Deep [Cheng et al., 2016] : DeepFM과 다르게 Wide Part의 Input을 직접 feature engineering 해야한다.

  이 모델의 Linear Regression(LR)을 FM으로 바꾸면 DeepFM과 비슷하지만 DeepFM은 Feature Embedding을 share한다.

  Embedding share 하는 방식은 low & high-order feature interaction을 표현하는 feature representation에 영향을 미쳐 더욱 정교하게 학습을 한다.(back-propagate manner)

  DeepFM은 사전 훈련과 Feature engineering 없이 low & high-order feature interaction을 포착할 수 있다.

  Experiments

  ---

  Experiment Setup

  DataSets :

  1) Criteo DataSet : 4,500만 명의 유저 클릭을 포함한, 13개의 continuous feature과 26개의 categorical feature가 있다.

  2) Company Dataset(아마 Huawei) :

  • 실제 산업의 CTR prediction을 평가하기 위해 회사 데이터에서 실험을 해 보았다. 회사의 App store에서 연속된 7일의 유저 클릭 기록을 사용하여 다음 하루치를 evaluate 하였다.

• 10억개 가량의 기록, app과 관련된 feature(identification, category and etc)와 user feature(유저가 다운로드한 앱), context feature(operation time and etc)가 있다.

Evaluation Metrics :

1) Logloss 2) AUC Score

Model Comparison

• 9개의 모델 실험 비교
  • LR, FM, FNN, PNN, Wide & Deep (Wide - LR & FM) , DeepFM

Performance Evaluation

Effciency Comparison

• LR 대비 학습시간에 걸린 시간을 나타내는 그래프

• FNN은 DeepFM에 비해 오래 걸린다. Pre-training에 시간을 많이 씀

• IPNN, PNN의 경우 Inner Product의 학습 속도가 굉장히 느려지는 걸 확인할 수 있다.

• Wide & Deep 모델보다는 살짝 느리지만 준수함

Effectiveness Comparison

• Feature interaction이 표현되지 않은 LR보다 interaction을 표현하는 다른 모델들이 성능이 더 좋다.

• Low-order & High-order feature interaction을 같이 학습하는 모델인 DeepFM과 Wide & Deep 모델이 다른 모델보다 성능이 좋다.

• Feature embedding을 share하는 DeepFM이 성능이 더 좋다.

  결과적으로 Wide & Deep 보다 AUC와 LogLoss 측면에서 각각 0.37% point, 0.42% point 성능이 좋아 졌다. 근소한 차이지만 Wide & Deep 논문에 의하면 Offline에서 0.275% 포인트 차이가 Online CTR에서는 3.9% point 차이로 이어졌다. 회사 AppStore에서 일일 전환율이 수백만 달러이기 때문에 작은 비율 상승은 년간 수 백만 달러의 추가 이익을 가져온다. 성능 향상이 효과적임을 확인할 수 있다. -Wide & Deep [Cheng et al., 2016]

Conclusions

• 이번 논문에서는 기존의 CTR예측 SOTA 모델의 단점을 극복하고 더 좋은 성능을 보인 모델인 FM기반 신경망 모델 DeepFM을 제시했다. DeepFM은 Deep Component와 FM Component를 jointly 학습한다. 이런 방식은 세 가지 장점이 있다.

  1) pre-training이 필요하지 않다.

  2) 높은 차원과 낮은 차원의 피쳐 상호작용을 같이 학습한다.

  3) Feature Engineering이 필요 없도록 feature embedding을 공유하는 전략을 사용한다.

  두 개의 real-word datasets 상에서 effectiveness측면이나 efficiency 측면을 다른 SOTA 모델과 비교했다. 실험 결과는 1) DeepFM이 AUC와 Logloss 지표에서 SOTA모델을 앞질렀고 2) 제일 efficient한 모델과 비교할 만큼 성능이 좋았다.

• 두 가지 후속 연구 방향이 있다. 하나는 높은 차원의 피쳐 상호작용을 강화하는 방법(예를 들면 pooling layer를 도입)을 탐색해보는 것이고 다른 하나는 GPU cluster상에서 large-scale problem을 DeepFM에서 학습하는 것이다.

참고 자료

• Factorization Machines
• DeepFM: A Factorization-Machone based Neural Network for CTR Prediction
• 초 간단 논문리뷰|DeepFM
• Factorization Machines for Item Recommendation with Implicit Feedback Data
• HyeJinLee, [논문 리뷰] DeepFM

1. Introduction

추천시스템에서 개인화는 유저의 서비스 이용시간을 늘려 수익 창출로 이어집니다. 전통적으로 많이 사용된 유저의 feedback 정보는 user-item rating과 click through rate(CTR)이 있습니다.

user-item rating은 사용자의 선호 정보를 알수있는 explicit feedback 이지만, 이러한 explicit feedback 정보가 제공되지 않을때가 있습니다. CTR은 유저의 선호에 대해 보다 제한된 정보를 제공하는 implicit feedback입니다. 이 때문에 CTR을 유저의 아이템에 대한 선호 지표로 사용하기에 어려움이 있습니다. 유저가 아이템을 실수로 클릭할수도 있고, 아이템을 클릭했지만 아이템을 마음에 들어하지 않을 수도 있기 때문입니다.

따라서 유저의 선호를 보다 정확히 파악할 수 있는 지표가 필요한데, 본 논문은 유저가 아이템에 머문 시간(dwell time)을 유저의 아이템에 대한 만족도를 나타내는 지표로 사용합니다. 나아가 논문은 이런 dwell time의 수집 방법, 정규화 방법, learning to rank 및 collaborative filtering 에서의 적용 방법을 논의합니다.

논문의 제시하는 contribution은 다음과 같습니다.

• 유저의 아이템 단위 컨텐츠 소비시간(dwell time)을 측정해 유저의 선호를 파악하는 새로운 방법을 제시

• 사용기기(pc, 핸드폰, 태블릿)에 따라 차이나는 아이템 dwell time의 정규화 방법 제시

• content recommendation 상황에서의 dwell time에 대한 empirical 분석

• dwell time을 이용한 learning to rank 과제

• dwell time을 이용한 collaborative filtering 과제

2. Related Work

Dwell Time in Other Domains

post-click dwell time은 IR(information retrieval), 웹 검색(web search) 영역에서 주로 검색어와 결과 컨텐츠의 관련성을 분석하고, 검색엔진의 성능을 높이는 용도로 연구되었습니다.

한편 논문에 따르면 dwell time을 개인화된 추천 시스템에 적용한 선행연구는 없다고 합니다.

Learning to Rank in Web Search

정보검색(information retrieval) 영역은 검색(query)에 대한 검색결과의 'relevance'를 높이는 것을 목표로 합니다. 'relevance'는 다소 추상적 개념으로, query와 검색결과의 관계에 대한 객관적 수치입니다.

한편 논문은 개인화된 정보검색을 위해서 이러한 객관적 relevance를 정확히 예측하는 것보다 dwell time를 정확히 높일 것을 주장합니다. 기존 IR 영역의 machine learning to rank(MLR) framework의 gradiented boosted decision trees, 또는 pairwise models(RankBoost, AdaRank), listwise models(RankNet, ListNet)를 사용해 relevance 대신 dwell time을 정확히 예측하는 식으로 적합합니다.

Collaborative Filtering

Collaborative Filtering 알고리즘은 대개 user의 explicit feedback를 사용하거나, binary implicit feedback을 사용합니다.

한편 논문과 같이 dwell time을 이용하는 선행연구는 드뭅니다.

3. Measuring Item Dwell Time

3.1 Dwell Time Computation

유저의 item 단위 dwell time 을 측정하는 것은 쉽지 않습니다. 예를들어 요즘의 브라우저는 여러개의 탭을 활용할 수 있고, 여러개의 탭 중에 유저가 주의를 기울인 아이템이 무엇인지 파악하기 쉽지 않습니다.

유저의 아이템 dwell time을 측정하는 두가지 보편적 방법은 client-side logging과 server-side logging입니다. client-side logging은 유저의 세밀한 행동과 주의를 측정할 수 있지만 브라우저에 따라 데이터 손실의 위험이 있습니다. client-side logging 정보를 이용할 수 없을때 server-side logging의 정보를 통해 dwell time에 대해 근사를 해 계산해야합니다.

Client-Side Dwell Time

client-side logging은 다음과 같은 Javascript/DOM events를 활용합니다.

위의 예에서 DOM-ready는 페이지 body의 준비시간을 나타내며 dwell time의 시작시간입니다. Focus는 user가 주의를 기울임을, Blur는 user가 주의를 기울이지 않음을 의미합니다. BeforeUnload는 페이지가 꺼지기 직전 시간을 나타냅니다.

이로부터 client-side dwell time은 $(t_3 - t_2) + (t_5 - t_4)$로 계산됩니다. client-side logging은 탭이 여러개인 상황에서도 유저의 dwell time을 정확히 파악할 수 있습니다.

하지만 Javascript가 정확히 작동하지 않거나, client-side 정보가 server-side로 정확히 전달되지 않는다면 정보 손실이 있을 수 있습니다. 예를들어 유저가 Javascript를 해제하거나, 인터넷 연결이 끊기는 경우가 있을 수 있습니다.

Server-Side Dwell Time

client-side logging 정보가 제공되지 않으면 server-side logging 정보를 통해 user의 dwell time을 파악해야 합니다. 이때 휴리스틱에 의한 근사를 해야합니다.

다음과 같은 로그 정보가 있을때,

${i, Click, t_1 } \rightarrow {j, Click, t_2 } \rightarrow {k, Click, t_3 } \rightarrow {i, Comment, t_4} \rightarrow {n, Click, t_5}$

2가지 방법으로 dwell time을 계산할 수 있습니다. FB(Focus/Blur)과 LE(Last Event) 방법입니다.

FB(Focus/Blur) : $i$에 대한 dwell time은 $(t_2 - t_1) + (t_5 - t_4)$로 계산됩니다. 아이템에 대해 주의를 기울인 시간(Focus)과 그렇지 않은 시간(Blur) 시간을 로그를 통해 추정하는 것입니다.

LE(Last Event) : $i$에 대한 dwell time은 $t_4 - t_1$ 입니다. 이 방법은 $i$에 대한 첫 행동과 마지막 행동의 시간차를 통해 dwell time을 계산합니다.

FB는 dwell time에 대한 추정이기 때문에 실제 dwell time과 오차가 있을 수 있습니다. 마찬가지로 LE 방법은 한 아이템에 대한 시작 행동과 끝 행동 사이의 전기간을 dwell time으로 추정하기에 dwell time을 실제보다 크게 과대추정할 수 있으며, 반면 마지막 행동의 시작시간을 dwell time 계산의 끝 시간으로 계산하기 때문에 dwell time을 과소추정할수도 있습니다.

실제 이틀간의 client-side logging과 FB, LE에 따라 계산한 dwell time의 평균은 다음과 같습니다.

1, 3, 5 열은 아이템의 개수, 2, 4, 6 열은 평균 dwell time입니다. 같은 데이터에 대해서 수집과정의 차이 때문에 1, 3, 5 열의 아이템 개수가 차이가 납니다. 또한 실제 client side log와 FB 방법의 dwell time이 유사한 것을 확인할 수 있으며 FB dwell time을 client side dwell time의 추정값으로 사용하는 것이 적절해 보입니다.

3.2 Dwell Time Analysis

dwell time 에 대한 그래프를 그려 그 특징을 더 분석해봅니다.

사용하는 데이터는 다음과 같은 야후의 뉴스기사 검색 로그 데이터입니다.

서로 다른 기기에서 아이템에 대한 log - dwell time을 그려보면 다음과 같은 정규분포 모양이 나옵니다(Figure2).

뉴스기사의 길이와 dwell time이 비례하는지 확인하기 위해 그래프를 그려봅니다(Figure3). x축은 뉴스의 길이, y축은 해당 뉴스에 대한 유저들의 평균 dwell time 입니다. 대체로 선형적 관계를 띄고, 뉴스기사 길이가 지나치게 길어지면 관계가 약해집니다.

몇가지 특징으로 뉴스기사마다 평균을 내지 않고 모든 유저, 모든 아이템의 dwell time을 그리면 선형관계가 분명하지 않았습니다. 그리고 긴 dwell time에 대해 기사의 길이 이외에 유저의 관심도를 함께 고려해야 합니다.

사진으로 구성된 slideshow에 대해 사진 개수(x축)에 대한 유저의 평균 dwell time(y축)을 그린 그래프는 다음과 같습니다(Figure4). 마찬가지로 선형적 관계를 보입니다.

3.3 Normalized Dwell Time

서로 다른 기기(pc, 핸드폰, 태블릿)에 따른 dwell time, 그리고 서로 다른 아이템 유형(글, 사진, 영상)에 따른 dwell time에 차이가 있습니다.

다음은 slideshow(사진)에 대한 log - dwell time(Figure 5), 그리고 영상에 대한 log - dwell time(Figure 6)의 그래프입니다.

서로 다른 context(기기와 아이템 유형)에 따라 아이템 dwell time이 다르므로, dwell time의 비교를 위해 이러한 차이를 표준화할 필요가 있습니다. 표준화는 다음의 과정을 따릅니다.

1. 각 context $C$에 대해, log - dwell time의 평균 $\mu_C$과 표준편차 $\sigma_C$를 구합니다.
2. context $C$의 새로운 아이템 $i$에 대해 표준화된 log dwell time $z_i$를 다음과 같이 구합니다: $z_i = \frac{ log(t_i) - \mu_{C_i} }{ \sigma_{C_i} }$.
3. 새로운 context 예를 들어 article context에서의 아이템 $i$의 dwell time을 다음과 같이 구합니다: $t_{i, article} = exp(\mu_{article} + \sigma_{article} \times z_i)$.

3.4 Predicting Dwell Time

아이템의 dwell time 정보가 없을때 이를 예측하기 위한 모형을 구성할 수 있습니다.

Support Vector Regression(SVR)을 이용합니다. log - dwell time 이 목표변수이며, feature로 기사의 context, 길이, 주제 카테고리 등을 사용합니다. 적합한 SVR 모형의 feature에 대한 weight 값은 다음과 같습니다. 대략적으로 weight는 dwell time에 영향을 미치는 정도를 나타냅니다.

4. Use Case I : Learning to Rank

아이템 dwell time을 machine learning to rank(MLR)을 이용한 추천시스템 모델에 사용하는 법에 대해 논의합니다.

The Basic MLR Setting

전통적 IR 세팅에서 query $q$와 document $d$가 있고, 이 둘을 파라미터로 받는 response $y_{q,d}$가 있습니다. $y$는 query에 대한 document의 relevance와 관련됩니다. MLR은 머신러닝 모델을 사용해 $y_{q, d}$값을 정확히 예측하는 모형을 만듭니다.

논문의 저자는 위의 과정을 content recommendation 에 적용합니다. user의 관심을 query로, 아이템(ex 기사)를 document로 봅니다. 이를 위해 user의 관심을 정량적인 변수로 나타내야 하고, query-document relevance를 user의 활동으로부터 추론해야 합니다. 논문은 첫번째 문제 대신 두번째 문제에 집중해 설명합니다.

기본적으로 user가 아이템에 click한 행동을 이용해, $y_{d,u} \in {0, 1}$와 같이 binary 변수를 설정하고 $y_{d, u}$를 예측하는 모델을 만들 수 있으며 이것은 논문의 도입부에 나온 CTR 예측과 일치합니다.

논문은 Gradient Boosted Decision Tree(GBDT) 알고리즘을 이용하며 알고리즘에 대한 설명은 다음과 같습니다.

GBDT 알고리즘은 트리 앙상블의 합으로 이루어진 회귀모형입니다. 모형은 각 $t$ 시점에서 현재 시점의 오차와 로스 함수의 그라디언트에 추가적으로 적합하는 식으로 순차적으로(step wise)하게 구성됩니다. 다음과 같은 형태의 additive 모형이 적합됩니다.

$f_t(x) = T_t(x; \Theta) + \lambda \Sigma_{t=1}^T \beta_t T_t (x; \Theta_t)$

Dwell Time for MLR

Dwell Time을 위의 GBDT 알고리즘에 적용하는 몇가지 방법이 있습니다. $\gamma_i$ 를 아이템 $i$의 평균 dwell time이라고 한다면, 1) $y_i = h(\gamma_i)$와 같이 목표변수를 dwell time에 관한 함수로 바꿀 수 있습니다. 2) 그외에 아이템 GBDT를 학습하는 과정에서(로스와 그라디언트에 추가적으로 적합하는 과정), 각 아이템에 대한 weight를 dwell time에 비례한 함수로 줄수있습니다.

이와 같은 세팅으로 야후 사이트에서 직접 수집한 데이터에 대한 모델의 offline evaluation 성능 결과는 다음과 같습니다. train, test 데이터는 7:3으로 나누었습니다. 앞서 dwell time을 이용하는 2가지 방법 중, dwell time을 학습과정에서 아이템의 weight로 사용하는 것이 가장 성능이 좋았음을 알 수 있습니다.

다음으로 모델의 online 상황에서의 성능을 확인하기 위한 실험을 진행했습니다. A는 click 여부(binary)를 $y$로 두고 적합한 선형 모델, B는 click 여부를 $y$로 두고 적합한 GBDT 모델, C는 dwell time을 목표변수로 두고 적합한 GBDT 모델입니다. A, B, C 세 모델을 online 추천 상황에서 사용했을 때, CTR 지표와 user engagement 지표를 비교함으로써 online 상황에서 성능이 좋은 모델을 보는 것입니다.

처음 3일은 같은 baseline 모델을 이용했고, 이후 A, B, C의 모델을 나누어 이용했을때 성능 차이를 볼 수 있습니다. Dwell time을 정확히 예측하는 모델을 이용해 추천을 하면, CTR, user engagement 등의 지표의 성능도 올라갑니다.

한편, 아쉽게도 학습한 MLR 모형을 추천에 정확히 어떻게 적용하는지 논문에 자세히 설명되어있지 않으며, user engagement 지표가 정확히 어떤 것인지에 대해서 기업 내부적 내용이라는 이유로 설명하지 않습니다.

5. Use Case II : Collaborative Filtering

Collaborative Filtering 방법을 통해 유저와 유사한 취향을 가진 사람의 소비 정보를 이용해 유저에게 아이템을 추천할 수 있습니다. 이때 주로 사용되는 것은 Matrix Factorization 방법입니다.

저자는 기존 MF 방법에서 사용된 user-item rating 혹은 user-item click 정보 대신, user-item dwell time 정보를 이용하는 방법을 제안합니다.

Setting

Matrix Factorization의 세팅은 다음과 같습니다:

• User feedback $M \times N$ 행렬 $I$

• $I$의 성분 $r_{i,j}$는 dwell time이고, $r_{i,j} \in R$ 또는 $r_{i,j} \in [0, 6]$

• $I$를 $U$, $V$로 분해

objective 함수는 다음과 같습니다:

• $argmin_{U,V} \Sigma_{i=1}^{M} \Sigma_{r_{i,j} < r_{i,k}} U_i(V_j - V_k)^T + \lambda(|U|_2 + |V|_2)$

• $r_{i,j}$는 positive example, $r_{i,k}$는 negative example 이며 rank-based optimization이 사용됨

* 위 내용은 논문의 표기를 그대로 쓴것이지만, 표기된 대로라면 $r_{i,j}$가 negative examples, $r_{i,k}$가 positive examples가 되어야 할 것 같습니다.

Dataset

3개월간의 Yahoo 데이터를 이용해 데이터셋을 구성합니다. 10개 클릭 미만의 user / item 을 제거한 결과 총 147,069 user와 11,535 아이템이 있었으며, train set는 4,358,066 개의 event, test set는 199,420 개의 event로 구성되었습니다.

Evaluation Method and Metrics

전체 데이터를 여러 시간대로 쪼개어 시간대에 따른 모델을 만듭니다. 또 절대적 click / non-click의 수치를 예측하기보다 MAP(Mean Average Precision), NDCG(Normalized Discounted Cumulative Gain)의 ranking 기반 metric으로 모델의 성능을 평가합니다.

Experimental Results

3개월의 데이터 중 앞 3개월의 데이터를 train set, 마지막 1개월의 데이터 일부를 test set으로 놓고 실험을 하는 것과, 하루, 일주일을 test 단위로 해 실험을 진행하는 것입니다. 그 결과는 다음과 같으며 두 경우 모두 click을 타겟으로 한 것보다 dwell time을 타겟으로 했을때 성능이 더 좋은 것을 확인할 수 있습니다.

1 | Introduction

추천시스템에서 쓰이는 NLP 모델 중 Transformer 등의 기존의 Unidirectional Model은 시퀀스를 왼쪽에서 오른쪽의 순서로 읽어가며 빈 칸을 예측합니다. 그러나 추천시스템의 경우에는 자연어와 달리 natural order가 존재하지 않고, 품사 등의 제한이 없습니다. 또한 관측할 수 없는 다양한 외부 요인 때문에 사용자의 행동 순서에서 숨겨진 representation이 제한됩니다. 예를 들어 위의 그림을 보면, '오늘은'으로는 뒤의 '하늘에'를 예측하기가 굉장히 어렵습니다. 그러나 만약 양방향으로 '하늘에'와 '많네요'를 둘 다 참조한다면 더 예측하기가 수월해지기 때문에, 논문의 저자들은 Deep한 양방향 Self-Attention 모델로서의 BERT를 추천시스템에 제안했습니다.

BERT

우선 BERT의 모델에 대해서 간단하게만 살펴보겠습니다. BERT는 Bidirectional Encoder Representation from Transformers를 줄인 이름으로, 문맥을 양방향으로 이해해서 숫자의 형태로 바꾸어주는 딥러닝 모델입니다. Transformer를 기반으로 문장 전체를 모델에 알려주고 [MASK]에 해당하는 단어를 예측하게 되는데, 크게 Pre-training 부분과 Fine-tuning 부분으로 나뉘어져 있습니다. 먼저 대용량으로 unlabeled 데이터로 모델을 pre-training 한 후, fine-tuning을 통해 특정 태스크를 가지고 있는 labeled 데이터로 전이학습을 하여 다양한 자연어처리 태스크를 수행합니다.

1) Input Representation

그럼 BERT에 input이 어떻게 입력되어 처리되는지 순서대로 보도록 하겠습니다. 먼저 Input Representation에서는 3가지 임베딩이 쓰이게 됩니다.

WordPiece Embedding

첫 번째는 Word Embedding으로, 문장을 토큰 단위로 분리하게 됩니다. 만약 'playing'이라는 단어가 있다면, 이를 'play'와 '##ing'으로 분리하여 두 가지 의미를 명확하게 전달합니다. 덕분에 신조어나 오탈자 등의 흔치않은 단어가 있는 input도 학습할 수 있습니다. 추가적으로 2개의 스페셜 토큰이 쓰입니다.

• [CLS] : Classification Label Token, 문장의 맨 처음에 등장하여 모든 벡터를 참고한 뒤에 context vector로 쓰임
• [SEP] : 두 문장을 구분하는 토큰

Segment Embedding

Segment Embedding에서는 두 개의 다른 문장을 구분합니다. 이는 두 개의 문장이 입력될 때 각각의 문장에 서로 다른 숫자를 더하여, 모델로 하여금 두 개의 서로 다른 문장이 있다는 것을 쉽게 알려줍니다.

Positional Embedding

마지막으로 Positional Embedding은 sin, cos 함수를 이용하여 토큰들의 상대적 위치 정보를 알려줍니다. Transformer를 기반으로 하는 모델이기에, 따로 토큰들에 위치 정보가 포함되어있지 않기 때문에 이렇게 상대적 위치를 더 쉽게 계산 가능하게 합니다.

2) Pre-training

Masked Language Model

이제 input이 준비되었으니 Pre-training 모델에 들어가게 됩니다. Pre-training은 크게 두 가지 기능을 하게 됩니다. 첫 번째는 Masked Language Model을 통하여 단어 중 일부를 [MASK] 토큰으로 바꾸고, 이를 예측하는 태스크를 수행하는 것입니다. 이를 통해 모델이 문맥을 파악하는 능력을 기를 수 있습니다.

Next Sentence Prediction

다음은 앞의 문장과 뒤의 문장이 이어지는지 판별하는 Next Sentence Prediction입니다. 이는 binary classification으로 [CLS] 토큰의 final hidden state에서 판별하는데, 이를 통해 모델이 두 문장 사이의 관계를 이해하도록 합니다.

3) Fine-tuning

이제 pre-training된 모델에 사용자의 태스크에 맞게 layer를 쌓아 fine-tuning을 합니다. 이 부분은 생략하도록 하겠습니다.

BERT4Rec 제안

앞서 언급했듯 일방향의 모델은 한계점이 있으므로 양방향의 context를 통해 맥락을 파악하고, data leakage를 막고 data augmentation도 활용하고자 Masked Language Model를 사용하여 다음 아이템을 예측하고자 추천시스템에 BERT를 활용하게 되었습니다. 단어가 들어갈 위치에 아이템을 넣고 random하게 마스킹하여 주변 맥락으로 아이템의 ID를 예측합니다.

2 | Model Structure

Problem Statement

그럼 이제 수식으로 문제를 정의해보겠습니다. 무엇을 상호작용으로 잡을지는 도메인과 태스크에 따라 달라집니다. 예측은 유저가 선택할 수 있는 모든 가능한 아이템들의 확률을 구하여 모델링합니다.

Model Architecture

전체 모델 구조를 보시면 앞으로만 정보를 전달하는 기존의 RNN 기반 방법과 달리 Self-Atttention을 활용하여 거리가 멀어져도 의존도를 반영할 수 있습니다. 또한 이전 글에서 다룬 SASRec과 비교해보자면, SASRec은 마지막 1개에만 [MASK]를 하는 반면 BERT는 다른 곳에 더 여러 개의 [MASK]를 쓰게 됩니다. 이 밖에도 SASRec은 Single-head Attention, BERT는 Multi-head Attention을 씁니다.

Transformer Layer

Multi-head Self-Attention

① h개의 subspace에 projection 후 concatenate

각 l 레이어에서 hidden representation h를 계산한 후, 이걸 모두 쌓아서 Attention 함수에 넣습니다. Multi-head로 각각의 input sequence에 서로 다른 가중치행렬을 곱하여 더 작은 사이즈의 Q, K, V 행렬을 만듭니다. 이 가중치행렬을 학습이 되며, 레이어 간에 변수는 공유하지 않습니다.

② Scaled Dot-Product Attention

여기서 사용되는 Attention Map은 key와 query의 관계 행렬을 사용하게 됩니다. 더 좋은 어텐션 분포를 위해 scaling도 합니다. 이후 각각의 head들의 contextual vector를 합쳐 Multi-head Self-Attention이 나옵니다.

Position-wise Feed-Forward Network

앞서 얻은 Multi-Head Self-Attention은 linear projection이기 때문에 비선형성을 주어야합니다. 이를 위해 FC Layer에 GeLU 함수를 활성화 함수로 사용합니다. GeLU는 Gaussian Error Linear Unit으로 BERT에서 제안된 함수인데, ReLU와 달리 음수에 대해서도 미분이 가능해 약간의 그래디언트를 더 전달할 수 있습니다. 이렇게 각 Attention Layer를 쌓는데, 너무 깊어지면 학습하기가 어려우므로 Transformer와 마찬가지로 Residual Connection과 Layer Normalization, DropOut을 함께 사용합니다.

Embedding Layer

앞서 언급했듯이, Transformer는 위치 정보가 포함되지 않기 때문에 Positional Embedding Layer를 추가합니다. 이때, sinusoid로 고정하지 않고 더 나은 성능을 위해 학습 가능한 Embedding Layer를 사용하여 Input Embedding Layer를 고정된 look-up table로 활용합니다.

Output Layer

최종 Output Layer의 수식입니다.

3 | Model Learning

모델을 학습할 때는 BERT처럼 [MASK]를 씌우고 이를 맞히게 하는 Cloze Task를 진행합니다. [MASK]가 여러 개인 경우네는 순차적으로 진행합니다. 구체적으로는 t 시점의 아이템 v를 마스킹하고, h를 기반으로 예측합니다.

Negative Log Likelihood를 이용하여 label과 예측값 간의 loss를 정의합니다. 원래 자리가 ground truth가 되고, 나머지는 negative sample이 됩니다. 그리고 이 loss fuction을 통해 ground truth는 점수가 높게, negative samples는 점수가 낮게 나오도록 합니다.

마지막으로, BERT는 학습할 때와 실제로 테스트할 때의 태스크가 다릅니다. 기존 자연어처리 분야에서 제안된 BERT 모델은 pre-training 용도이기도 하고, representation learning이 목적이기 때문에 end-to-end 모델이 아닙니다. 그러나 BERT4Rec에서는 next item을 예측하는 태스크의 end-to-end 모델이 필요했기 때문에, 모델 학습의 마지막 부분에 fine-tuning 개념으로 마지막 아이템을 마스킹하여 이를 맞히는 태스크를 더 진행합니다.

4 | Experiment & Conclusion

Dataset

데이터는 Beauty, Steam, ML-1m, ML-20m를 사용하는데, 앞에 2개는 sparse한 데이터, 뒤에 2개는 dense한 데이터입니다. ML 같은 경우에는 영화 평점의 explicit feedback인데 이를 0과 1로 구분하는 implicit feedback으로 바꾸어 사용했습니다. Label은 Ground Truth와 인기순으로 100개를 뽑은 Negative Samples로 이루어져있습니다.

Evaluation

• HR@k: 내가 추천한 상위 k개 아이템 중 다음 아이템이 있는 비율
• NDCG@k: 내가 추천한 아이템들의 순위 점수 / k개 아이템의 이상적 순위 점수
• MRR: Grount Truth가 몇 순위에 있는지 위치 별로 점수 획득

Experiments

Baseline 비교

다음 아이템 맞히기에 대한 성능 비교 결과입니다. 단순 BERT만 사용했음에도 불구하고 다른 모델보다 좋은 성능을 보여줍니다. 추가적으로 POP, BPR-MF, NCF, FPMC는 딥러닝 모델이 아니지만 다른 딥러닝 모델들과 큰 성능 차이는 없는 것으로 나타났습니다.

Self Attention vs. Masked Learning

양방향을 사용할 때와, 마스크 수를 조절할 때의 성능을 비교해보았는데 양방향을 통해 유의미하게 성능이 개선되었고, 적당한 마스크 수는 성능 향상에 도움이 된다는 것을 알 수 있습니다.

Transformer의 Hidden Dimension

SAS4Rec, BERT4REc으로 갈수록 정보가 많아지고 모델이 커지기 때문에 차원 수도 커져야 할 필요가 있었습니다. 차원은 128차원과 64차원일 때 제일 좋았습니다.

Mask의 비율

Dataset의 density를 기준으로 마스크의 비율을 비교해보았습니다. Dataset이 적당히 dense 할수록 성능이 향상되었지만, 너무 많이 dense 한 경우에는 성능 저하가 발생했습니다.

Maximum Sequence Length

이는 시퀀스 길이를 최대 얼마로 해야되는지에 대하여 알아보기 위함인데, Next Item 예측에서 최신 아이템을 많이 받을수록, 즉 N이 클수록 성능이 향상되었습니다. 너무 많은 정보는 패턴에서 noise까지 학습하기 때문에 성능이 저하됩니다.

Conclusion

의의

• Bidirectional Self-Attention을 추천시스템에 적용하여 좋은 성능을 보임

한계

• 아이템에 항상 순서가 정해져있는 것은 아님
• 아이템과 유저가 정해져있지 않음
• 기술적으로 아이템의 시퀀스를 유저별로 저장하기 어려움
• 도메인에 따라 아이템의 생명주기가 확실
• 외부 요인으로 인하여 Offline Evaluation과 Online Result가 다른 경우가 많음
• 다른 딥러닝을 이용하지 않은 모델에 비해 상대적으로 학습 속도가 느림 (실용적이지 않음)

앞선 논문 리뷰 게시물에 이어서 이번에는 SASRec을 Pytorch로 구현한 코드를 리뷰하겠습니다. 구현된 코드는 이 깃헙에서 보실 수 있습니다. 참고로 Tensorflow로 구현된 코드는 논문 저자의 github에 업로드되어 있으며, 파이토치와 텐서플로우 버전 모두 모델링 부분을 제외하면 동일한 코드와 구성을 이루고 있기 때문에 해당 리뷰에서는 파이토치 버전을 다루고자 합니다.

Overview

전체적인 SASRec의 구조는 다음과 같습니다. input 시퀀스는 Embedding Layer를 거치고 Self Attention Layer(S-A layer)와 Point-Wise Feed Forward Network(P-W FFN)로 이루어진 블럭을 거쳐 최종 Prediction Layer를 거친 이후, 유저가 다음에 선택할 아이템을 예측하게 됩니다. 본 코드에서는 오른쪽 그림과 같이 총 2개의 블럭이 쌓여있어 S-A layer와 P-W FFN을 각각 2번씩 지나게 됩니다.

지금부터 하나의 예시 데이터를 가지고 input에서부터 output이 나오는 과정을 1~5번까지 코드와 함께 차례로 살펴보겠습니다.

1. Input Action Sequence

저희가 살펴볼 데이터는 영화 평점 데이터 Movie Lens Dataset입니다. 본 데이터셋은 User ID, Movie ID, Ratings, Timestamps로 이루어져 있으며 각 유저의 관람 영화와 평가 점수, 관람 시각 등의 정보가 담겨있습니다.

SASRec은 이 중 Implicit information인 유저의 관람 영화 시퀀스만을 필요로 하기에 데이터 txt 파일에서 User ID와 Movie ID만을 불러와 User 딕셔너리를 구성하게 됩니다. 이때 User ID는 key, Movie ID는 각 key에 해당하는 value가 됩니다. 또한 유저의 관람 시퀀스 리스트에서 후반 2개의 영화는 각각 valid와 test set을 구성하는데 활용됩니다.

이 과정에 해당하는 코드는 utils.py에 구현되어 있으며 아래와 같습니다.

def data_partition(fname):
    usernum = 0
    itemnum = 0
    User = defaultdict(list)
    user_train = {}
    user_valid = {}
    user_test = {}
    # assume user/item index starting from 1
    f = open('data/%s.txt' % fname, 'r')
    for line in f:
        u, i = line.rstrip().split(' ')
        u = int(u)
        i = int(i)
        usernum = max(u, usernum)
        itemnum = max(i, itemnum)
        User[u].append(i)

    for user in User:
        nfeedback = len(User[user])
        if nfeedback < 3:
            user_train[user] = User[user]
            user_valid[user] = []
            user_test[user] = []
        else:
            user_train[user] = User[user][:-2]
            user_valid[user] = []
            user_valid[user].append(User[user][-2])
            user_test[user] = []
            user_test[user].append(User[user][-1])
    return [user_train, user_valid, user_test, usernum, itemnum]

이어서 각 유저마다 관람한 영화 개수는 모두 다르기 때문에 input data를 구성하기 위해서는 시퀀스의 길이를 통일하여 하나의 텐서로 구성해야합니다. 1번 유저(pink)처럼 시퀀스 최대 길이인 max_len(200)보다 짧은 시퀀스는 남은 자리를 0으로 채우는 zero-padding 과정을 거치고, 6040번 유저(gray)처럼 max_len(200)보다 긴 경우에는 200개를 초과하는 초반 영화들을 모두 삭제하게 됩니다. 이 과정을 통해 batch_size(128)xmax_len(200) size를 가진 seq 인풋 텐서(orange)가 만들어지고, 동시에 동일한 사이즈의 pos(blue)와 neg(green)텐서가 만들어집니다.

pos는 유저들이 가장 처음으로 관람한 영화 ID를 제거하고 마지막으로 관람한 영화 ID를 추가한 텐서로 ground truth를 나타냅니다. 반면, neg의 경우, 유저가 관람하지 않은 영화 목록에서 랜덤으로 한개씩 뽑아 pos와 동일한 사이즈로 구성합니다. pos와 neg는 후에 Prediction Layer에서 loss를 계산하는 과정에 쓰일 예정이며, Embedding Layer로 들어갈 input은 seq 텐서가 됩니다.

이 과정에 해당하는 코드는 utils.py에 구현되어 있으며 아래와 같습니다.

def random_neq(l, r, s):
    t = np.random.randint(l, r)
    while t in s:
        t = np.random.randint(l, r)
    return t


def sample_function(user_train, usernum, itemnum, batch_size, maxlen, result_queue, SEED):
    def sample():

        user = np.random.randint(1, usernum + 1)
        while len(user_train[user]) <= 1: user = np.random.randint(1, usernum + 1)

        seq = np.zeros([maxlen], dtype=np.int32)
        pos = np.zeros([maxlen], dtype=np.int32)
        neg = np.zeros([maxlen], dtype=np.int32)
        nxt = user_train[user][-1]
        idx = maxlen - 1

        ts = set(user_train[user])
        for i in reversed(user_train[user][:-1]):
            seq[idx] = i
            pos[idx] = nxt
            if nxt != 0: neg[idx] = random_neq(1, itemnum + 1, ts)
            nxt = i
            idx -= 1
            if idx == -1: break

        return (user, seq, pos, neg)

2. Embedding Layer

1) Item Embedding

input으로 들어온 seq텐서는 Item Embedding을 거쳐 batch_size(128) x max_len(200) x d(50) 사이즈의 텐서로 변환됩니다.

2) Position Embedding

초기 위치값을 나타내는 텐서는 max_len(200)에 맞춰 0~199 사이의 값으로 batch_size(128)만큼 채워집니다. 이 텐서는 Position Embedding을 거쳐 아이템 임베딩 행렬과 마찬가지로 batch_size(128) x max_len(200) x d(50) 사이즈의 텐서로 변환됩니다.

이후, 두 텐서의 값은 더해지고, dropout 과정을 거치게 됩니다. 이어서 다시 한 번 zero-padding 과정을 거치게 되는데, 이 이유는 position embedding의 결과가 zero-padding 정보를 담고 있지 않기 때문입니다. 이렇게 완성된 텐서는 이어지는 Self-Attention Layer의 input인 Key와 Value가 되고, Layer normalization을 한 번 더 거친 텐서는 Query로 활용됩니다.

이 과정에 해당하는 코드는 아래 Self-Attention Layer와 Pointwise Feed Forward Network에 대한 설명 이후 한 번에 보여드리도록 하겠습니다.

3. Self-Attention Layer

Embedding Layer를 통해 만들어낸 Query, Key, Value 텐서는 각 가중치 행렬과의 선형결합 연산 이후 Self-Attention Layer을 거치게 됩니다. 해당 식은 위 슬라이드 수식을 참고해주시기 바랍니다. 이 때 주의해야할 점은 Query와 Key의 행렬곱 연산 이후 이전 시점에 대해 이후 시점의 영향력을 배제하기 위한 Attention Masking 과정이 추가된다는 점입니다. 이후 시점의 영화에 해당하는 값들을 모두 0으로 마스킹해주어 뒤이어올 Value와의 행렬곱 연산에서 이후 시점들의 값을 반영하지 않도록 해줍니다. 이렇게 완성된 텐서(skyblue)는 input과 동일한 차원인 batch_size(128) x max_len(200) x d(50) 사이즈로 이루어져 있으며, 이후 Residual Connection과 Layer Normalization을 차례로 거쳐 output(green)을 내보내게 됩니다.

4. Pointwise Feed Forward Network

Pointwise Feed Forward Network(이하 P-W FFN)은 선형결합 연산이 두 번 반복되는 것과 동일합니다. 해당 코드에서는 1d Convolution Layer를 통해 본 연산을 구현하였는데, 이때 주의할 점은 input으로 들어갈 텐서를 transpose(전치)시켜야 한다는 점입니다. 이는 1d Conv 연산의 특징에서 비롯하는데, 시퀀스의 time-step별로 kernel size 만큼 옆으로 이동하기 때문에 time step별로 input 텐서를 스캔하기 위해서는 전치를 해주어야 합니다.

위 그림처럼 노란색 커널이 관람 영화를 순서대로 스캔하면서 각 결과값을 내게 되고, 총 50개의 커널이 각 연산 과정을 거쳐 최종적으로 (transpose 이후의) input size와 동일한 batch_size(128) x d(50) x max_len(200) 사이즈의 텐서가 나오게 됩니다. 이후 dropout과 Relu(비선형 함수)를 거친 후 다시 한 번 1d Conv 연산과 dropout을 반복하게 됩니다.

다시 원래 형태로 돌리기 위해 transpose를 해주면 batch_size(128) x max_len(200) x d(50) 사이즈의 텐서로 돌아오게 되고, 여기에 초반 input 텐서(green)를 더해주는 Residual Connection 과정을 거치게 됩니다.

Self-Attention Layer와 P-W FFN을 거치면서 zero-padding의 정보는 또 한 번 유실되었기 때문에 이를 다시 유효화하기 위해 Embedding Layer에서 활용했던 timeline-mask를 다시 불러와 해당하는 위치에 0값을 채우게 됩니다.

이렇게 해서 완성된 텐서는 2번째 Block의 Self-Attention Layer의 input으로 들어가게 되고 동일한 과정을 반복하여 최종적으로 2개의 block(S-A Layer+P-W FFN)을 거친 output 텐서(purple)를 배출하게 됩니다.

2. Embedding Layer, 3. S-A Layer, 4. P-W FFN에 해당하는 코드는 model.py에 구현되어 있으며 아래와 같습니다.

class SASRec(torch.nn.Module):
    def __init__(self, user_num, item_num, args):
        super(SASRec, self).__init__()
        self.user_num = user_num
        self.item_num = item_num
        self.dev = args.device
        self.item_emb = torch.nn.Embedding(self.item_num+1, args.hidden_units, padding_idx=0)
        self.pos_emb = torch.nn.Embedding(args.maxlen, args.hidden_units) # TO IMPROVE
        self.emb_dropout = torch.nn.Dropout(p=args.dropout_rate)
        self.attention_layernorms = torch.nn.ModuleList() # to be Q for self-attention
        self.attention_layers = torch.nn.ModuleList()
        self.forward_layernorms = torch.nn.ModuleList()
        self.forward_layers = torch.nn.ModuleList()
        self.last_layernorm = torch.nn.LayerNorm(args.hidden_units, eps=1e-8)

        for _ in range(args.num_blocks):
            new_attn_layernorm = torch.nn.LayerNorm(args.hidden_units, eps=1e-8)
            self.attention_layernorms.append(new_attn_layernorm)

            new_attn_layer =  torch.nn.MultiheadAttention(args.hidden_units,
                                                            args.num_heads,
                                                            args.dropout_rate)
            self.attention_layers.append(new_attn_layer)

            new_fwd_layernorm = torch.nn.LayerNorm(args.hidden_units, eps=1e-8)
            self.forward_layernorms.append(new_fwd_layernorm)

            new_fwd_layer = PointWiseFeedForward(args.hidden_units, args.dropout_rate)
            self.forward_layers.append(new_fwd_layer)

    def log2feats(self, log_seqs):
        seqs = self.item_emb(torch.LongTensor(log_seqs).to(self.dev))
        seqs *= self.item_emb.embedding_dim ** 0.5
        positions = np.tile(np.array(range(log_seqs.shape[1])), [log_seqs.shape[0], 1])
        seqs += self.pos_emb(torch.LongTensor(positions).to(self.dev))
        seqs = self.emb_dropout(seqs)

        timeline_mask = torch.BoolTensor(log_seqs == 0).to(self.dev)
        seqs *= ~timeline_mask.unsqueeze(-1) # broadcast in last dim

        tl = seqs.shape[1] # time dim len for enforce causality
        attention_mask = ~torch.tril(torch.ones((tl, tl), dtype=torch.bool, device=self.dev))

        for i in range(len(self.attention_layers)):
            seqs = torch.transpose(seqs, 0, 1)
            Q = self.attention_layernorms[i](seqs)
            mha_outputs, _ = self.attention_layers[i](Q, seqs, seqs, 
                                            attn_mask=attention_mask)
            seqs = Q + mha_outputs
            seqs = torch.transpose(seqs, 0, 1)

            seqs = self.forward_layernorms[i](seqs)
            seqs = self.forward_layers[i](seqs)
            seqs *=  ~timeline_mask.unsqueeze(-1)

        log_feats = self.last_layernorm(seqs) # (U, T, C) -> (U, -1, C)

        return log_feats

5. Prediction Layer

1. Input Action Sequence에서 생성한 pos와 neg 텐서를 동일한 item embedding layer에 태워 P-W FFN을 거친 output(purple)과 동일한 사이즈(batch_size(128) x max_len(200) x d(50))의 텐서로 변환합니다. 변환된 텐서들을 P-W FFN을 거친 output(purple)과 Element-wise product 연산을 진행하여 같은 위치의 값들이 서로 곱해지도록 하여 새로운 pos와 neg 텐서를 생성합니다. 이어서 두 텐서들을 마지막 차원인 d(50)을 기준으로 모두 더하여 batch_size(128) x max_len(200) 사이즈의 텐서로 축소합니다.

이 과정에 해당하는 코드는 model.py에 구현되어 있으며 아래와 같습니다.

    def forward(self, user_ids, log_seqs, pos_seqs, neg_seqs): # for training        
        log_feats = self.log2feats(log_seqs) # user_ids hasn't been used yet

        pos_embs = self.item_emb(torch.LongTensor(pos_seqs).to(self.dev))
        neg_embs = self.item_emb(torch.LongTensor(neg_seqs).to(self.dev))

        pos_logits = (log_feats * pos_embs).sum(dim=-1)
        neg_logits = (log_feats * neg_embs).sum(dim=-1)

        return pos_logits, neg_logits # pos_pred, neg_pred

이렇게 해서 완성된 pos_logits과 neg_logits 텐서는 위 그림과 같이 이전 영화들을 고려했을때 다음 영화의 관련성 점수를 나타내는 $r_{{o_t},t}$로 구성됩니다. P-W FFN을 거친 output(purple)은 zero-padding이 반영된 상태이기 때문에 이 텐서에서 파생된 pos_logits과 neg_logits 텐서 역시 유저가 영화를 관람하지 않은 시퀀스는 0값으로 채워져 있게 됩니다. 실제로 유저가 관람한 영화 시퀀스 정보를 담고 있는 pos_logits는 각 값이 최대한 커야 이 값에 시그모이드를 취한 값이 1에 가까워져 log loss가 최소가 되고, 반대로 유저가 관람하지 않은 영화 목록을 통해 구성한 neg_logits의 경우 각 값이 최대한 작아야 시그모이드를 취한 값이 0에 가까워져 log loss가 최소가 되게 합니다.

이 과정에 해당하는 코드는 main.py에 구현되어 있으며 아래와 같습니다.

    for step in range(num_batch):
        u, seq, pos, neg = sampler.next_batch() # tuples to ndarray
        u, seq, pos, neg = np.array(u), np.array(seq), np.array(pos), np.array(neg)
        pos_logits, neg_logits = model(u, seq, pos, neg)
        pos_labels, neg_labels = torch.ones(pos_logits.shape, device=args.device), torch.zeros(neg_logits.shape, device=args.device)
        adam_optimizer.zero_grad()
        indices = np.where(pos != 0)
        loss = bce_criterion(pos_logits[indices], pos_labels[indices])
        loss += bce_criterion(neg_logits[indices], neg_labels[indices])

학습이나 추론 과정에서 loss를 구하는 것 외에도 다음 시점에서 관람할 영화를 예측하는 작업을 수행합니다. 유저가 다음에 관람할 영화 ID(ground truth)와 유저가 관람하지 않은 영화 100개로 이루어진 item_indices 벡터를 item embedding layer에 태워 101 x d(50) 차원의 텐서로 변환합니다. 이 텐서를 P-W FFN의 output(purple)에서 마지막 행의 데이터만 추출한 final_feat와 내적 연산을 수행하여 101 x 1 차원의 output을 반환합니다. 해당 벡터에서 가장 높은 값을 가진 인덱스에 해당하는 영화를 유저가 다음 시점에 관람할 영화로 예측하게 됩니다.

이 과정에 해당하는 코드는 model.py에 구현되어 있으며 아래와 같습니다.

    def predict(self, user_ids, log_seqs, item_indices): # for inference
        log_feats = self.log2feats(log_seqs) # user_ids hasn't been used yet

        final_feat = log_feats[:, -1, :] # only use last QKV classifier, a waste

        item_embs = self.item_emb(torch.LongTensor(item_indices).to(self.dev)) # (U, I, C)

        logits = item_embs.matmul(final_feat.unsqueeze(-1)).squeeze(-1)

        return logits # preds # (U, I)

Summary

Overview

• 해당 논문은 기존의 sequential recommender인 Markov Chains(MC)과 RNN 계열의 단점을 동시에 보완하고자 하였습니다.
• 이를 위해 당시 NLP task에서 sota인 Transformer 모델을 추천 시스템에 도입하였습니다. (Sequential data 특성 상, NL model에 적용하는 것은 어렵지 않기 때문에 해당 논문에서도 모델에 큰 변형을 가하지는 않았습니다.)
• 제안된 모델은 기존의 추천시스템에서 좋은 성능을 보여주던 MC/CNN/RNN based model을 뛰어넘는 실험 결과를 보여주었습니다.

이번 리뷰에서는 Transformer의 핵심만을 간단히 살펴보고, 기존 Transformer와의 차이를 위주로 진행하겠습니다.

Introduction

• Sequential recommender system은 유저의 최근 행동의 context를 기반으로 한 추천을 목표로 하고 있습니다.
• 이런 sequential recommender model을 개발하기 힘든 점은 입력 공간의 크기가 매우 크다는 것입니다. Context로 사용되는 유저의 행동에 따라 지수적으로 입력 공간이 증가하게 됩니다.

기존의 sequential recommender를 간략하게 살펴봅시다.

• Markov Chains (MCs) 유저의 다음 행동이 바로 이전의 과거 혹은 몇 개 이전의 행동에 영향을 받을 것이라는 가정을 합니다. 이러한 가정은 너무 over-simplfy하고 매우 희소한(sparse) 데이터에만 잘 작동한다는 단점을 가지고 있습니다. 따라서, 복잡한 관계를 학습하는 것은 힘듭니다.

• Recurrent Neural Networks (RNN) RNN 기반의 모델, 대표적으로 GRU recommender 같은 경우는, 과거의 모든 행동을 모델의 입력값으로 넣어, 이를 요약한 정보를 가지고 다음 행동을 예측합니다. 상대적으로 복잡한 모델을 학습하기 위해 많은 양의 데이터를 요구하기 때문에, 희소한 데이터에서는 좋은 성능을 보여주기 힘들다고 합니다.

저자는 이 둘의 단점을 보완하고자 새로운 모델을 추천 시스템에 적용하게 됩니다.

이미지: (left) Factorizing personalized Markov chains for next-basket recommendation / (center, right) BERT4Rec: Sequential Recommendation with Bidirectional Encoder Representations from Transformer

기존의 딥러닝에서 빈번하게 사용되는 CNN, RNN 계열 모델과는 다르게 Transformer는 self-attention이라는 새로운 메커니즘을 사용합니다. Self-attention은 문장을 구성하는 단어들 간 의미적, 구조적 패턴을 기존의 모델들보다 더 잘 파악하는 결과를 보여주었고, 이에 따라 기계 번역과 같은 어려운 태스크에서 매우 좋은 성능을 보여주었습니다. 저자는 self attention을 사용하는 Transformer로 MCs, RNN 모델의 한계를 극복하고자 하였습니다.

위의 이미지(page 6)에서 그림을 보시면 MCs, RNN, Transformer의 접근 방식의 차이를 확인할 수 있습니다. 앞서 설명했듯 MCs, RNN 계열 모델의 가정이 그림에서 드러나며, Transformer(Self-attention)와 어떤 차이가 있는지 확인할 수 있습니다. (Parallelization 관점에서도 생각해볼 필요가 있습니다.)

Transformer

2017년, Vaswari, et al. 의 "Attention is all you need"에서 발표된 Transformer에 대해 간략하게 살펴보겠습니다. Transformer의 설명에 사용된 이미지는 Jay Alarmmar의 블로그에서 가져왔으며, 이곳에 Transformer의 자세한 설명이 있으니 참고하시면 좋을 것 같습니다.

Overview

• Transformer는 크게 encoder blocks(stacking)과 decoder blocks(stacking)으로 구성되어 있습니다.
• Encoder block은 Multi-head attention, decoder block은 Masked Multi-head attention, encoder-decoder attention을 사용합니다.

이 3가지 self-attention과 positional encoding을 간단하게 살펴보겠습니다!

Encoder block vs. Decoder block

• Encoder, decoder block의 가장 큰 차이는 unmasked attention을 사용하였는지, masked attention을 사용하였는지 입니다. 위 그림의 입력 벡터를 보시면 좋을 것 같습니다.

(참고로, encoder, decoder block의 입력 벡터와 이를 통과한 벡터의 사이즈는 동일하게 유지됩니다. 그림에서도 사이즈가 4로 유지되는 것을 확인할 수 있습니다. 이러한 사이즈를 유지하기 위해, multi-head attention의 파라미터 사이즈 설정에 주의해야 합니다.)

Encoder block

• Encoder block은 크게 두 개의 레이어(Multi-headed attention, Feed Forward Neural Network)로 구성됩니다.
• MH attention과 FFNN에서 중요하게 살펴볼 차이점은 input들의 dependency의 유무입니다. (이 부분을 잘 기억해주세요.)

Multi-headed attention

"The animal didn't cross the street because it was too tired."

• 이 문장에서 it의 가리키는 혹은 내포하는 의미가 무엇일까요? 아마 'because', 'was'처럼 바로 주변 단어들은 아닐 것입니다. 여기서 중요한 것은 'it'이 의미하는 단어는 충분히 멀리 떨어져있을 수 있으며, 가리키는 혹은 내포한다라는 의미는 가장 유사한 단어(연관성이 높은)를 찾는 문제일 수 있습니다. 이를 모델에 반영하고자 self-attention이 등장합니다.
• Self-attention을 계산하는 것은 복잡하지 않습니다. Step1, step2 그림을 참고하시면 됩니다. 여기서 중요한 것은 Q,K,V 각각의 의미를 이해하는 것입니다. (Q,K,V는 마치 파이썬의 dictionary 객체와 같은 역할을 하고 있는데, Q: 내가 찾고하는 key value, K: dict에 저장된 keys, V: 각 key에 해당하는 value 라고 이해할 수 있습니다. 내가 어떤 key의 값을 찾기 위해, dict에서 key를 기준으로 찾아, 값을 가져오는 느낌입니다.)
• 만약 사람들에게 문장 안에서 'it'이 가리키는 단어를 고르라고 한다면, 모두가 같은 답변을 하지 않을 수 있습니다. 특히 더 복잡한 문장에서는 더더욱 그럴 것입니다. 이를 모델에 반영하고자 multi-headed attention을 사용합니다. (여기서 "multi-headed"는 서로 다른 사람의 시선을 앙상블하는 느낌으로 볼 수 있을 것 같습니다.)

Multi-headed attention 연산도 그림처럼 간단합니다. 여기서 주목할 만한 것은 출력 벡터의 사이즈입니다. (위에서 잠깐 언급했듯이, 사이즈를 유지하기 위해 head의 개수 등을 고려해줘야 합니다.)

Feed Forward Neural Network

(위에서 말했듯이 MH attention과 FFNN에서 중요하게 살펴볼 차이점은 input들의 dependency의 유무입니다.) 같이 논의해봅시다 :)

Decoder block

• Decoder block은 살펴볼 두 가지는 masked multi-head attention과 encoder-decoder attention 입니다.

Masked Multi-headed attention

• Decoder 부분부터는 실제 태스크를 풀기 위한 역할을 수행하기 위해서 masking을 해줍니다.
• 예를 들어, "아버지/가/방/에/들어가다"라는 문장이 있고, 순차적으로 다음에 올 단어 예측을 위해 "아버지/", "아버지/가", "아버지/가/방", ... 이런식으로 모델에 입력을 해줘야합니다.
• Transformer에서는 masking을 위해 매우 간단하게 -inf라는 값을 주었는데, 이는 sigmoid 혹은 softmax를 만났을 때 0의 값을 가지기 때문입니다.

Encoder decoder attention

• 해당 attention이 multi-head attention과 다른 점은 K,V를 encoder block에서 가져오는 것입니다.
• 즉 내가 찾고 싶어하는 Query는 decoder에서 생성하고 dictionary는 encoder에서 생성된 것을 쓰는 것입니다.

Positional encoding

• Self-attention을 살펴보았을 때, 내가 알고싶은 Q값과 유사한 쌍을 찾기 위해 모든 key-value를 살펴본 것을 확인할 수 있습니다. 즉, 나랑 얼마나 떨어져있는지에 대한 위치 좌표는 무시됩니다. 하지만 문장에서는 locality가 어느 정도 중요할 수 있고, 이를 입력 벡터에 어느 정도 반영하고자 positional encoding을 해주게 됩니다.
• 모델의 입력 시퀀스를 그대로 넣어주고 self-attention을 진행하는 것 대신, 간단하게 입력 시퀀스에 positional 값을 더해주면 됩니다.

Summary

Transformer GIF

Methodology

SASRec이 Transformer를 어떻게 추천 시스템에 적용하였는지 살펴보겠습니다. __Transformer와 일치하는 부분은 생략하였습니다. __

A. Embedding Layer

• 학습을 위해 action set의 사이즈는 $n$으로 고정하였습니다.
• 따라서 전체 아이템 임베딩 행렬의 사이즈는 $|I|\times d$, 입력 임베딩 행렬의 크기는 $n\times d$ 입니다.
• 앞서 언급한 positional encoding은 입력 벡터에 더해주는 형태이기 때문에 사이즈는 입력 임베딩 행렬과 동일합니다.
• 기존 Transformer와 차이가 있다면, 여기서는 Positional encoding을 고정된 값이 아닌, 학습 파라미터로 설정했다는 점입니다. (고정 positional encoding은 성능이 안 좋았다고 합니다.)

B. Self-Attention Block/C. Stacking Self-Attention Block/D. Prediction Layer

B.Self-Attention Block

• Encoder, Decoder block을 따로 구분하는 것 대신, 새로운 self-attention block을 제안함.
• 실험을 위해 2개의 self-attention block을 쌓았음.
• Causality) 실제 추천 알고리즘이 작동할 때는 미래의 유저 행동을 볼 수 없기 때문에, 저자는 미래의 유저 행동을 사용하는 것은 모순적이라고 생각하였습니다. 따라서, self-attention block에서 현재 이후 시점에 대해서는 masking을 진행했습니다.
• 즉, $Q_i$ and $K_j$, where $j>i$에 해당하는 연산을 masking 했습니다.

D.Prediction Layer

• 다음에 올 유저 행동을 예측하기 위해 적절한 item의 score를 최종적으로 예측하게 됩니다.
• 따라서 block의 출력 값 $F$에 사이즈가 $|I|\times d$ 인 $N$과 연산해줍니다. (임베딩 사이즈가 모두 $d$, 입력 임베딩 벡터 사이즈와 동일)
• Shared Item Embedding) 이때, 저자들은 $N$을 새로운 학습 파라미터 임베딩 값 대신, 모델 입력값으로 사용되었던 $M$을 재활용하게 됩니다. (학습할 파라미터가 줄어, overfitting을 방지했다고 함 -> 실제 실험 결과가 개선됨.)

E. Network Training

F. Complexity Anlysis

공간복잡도

• 논문에서는 SASRec과 FPMC 모델을 비교하였습니다. (다른 기존의 모델들의 공간복잡도가 FPMC와 비슷하다고 합니다.)
• 여기서 SASRec은 $|U|$ 텀이 없는데, 실제로는 $|U|$이 매우 크기 때문에 SASRec이 비교적 효율적임을 알 수 있습니다.
• $d$는 임베딩 사이즈로 $d<<|U|$ and $$d<<|I|$$이기 때문에 $d^2$ 무시함. ($|I|d$ : Item embedding matrix, $nd$: Positional encoding params)

시간복잡도

• SASRec: Self-attention layer와 FFNN layer의 시간복잡도는 $n^2d+nd^2$
• RNN-based: $n$
• 따라서, SASRec이 비교적 효율적이지 않을 수 있지만, 실제로 Transformer의 self attention과 ff layer는 병렬적으로 연산이 가능합니다. (발표자료 6페이지 그림을 살펴봅시다.)
• 반면, RNN-based는 순차적으로 진행할 수 밖에 없습니다. (참고자료)

Experiment

Datasets/Evaluation Metrics

• 실험 데이터셋은 총 4개이며 각각의 통계량은 발표자료를 참고해주세요.
• 평가 메트릭은 지금까지 다룬 페이퍼들과 같습니다.
• 저자들은 4가지의 질문을 던지며, 이에 대한 답을 실험결과로 보여주었습니다.

RQ1

RQ2

RQ3/RQ4

Summary

1. Introduction

1.1 Session-based Recommendation

• 기존 추천 시스템은 대부분의 유저 프로필과 과거 행동 데이터들이 끊임없이 저장된다고 가정한다.
• 하지만 실제 서비스에서는 유저의 신원을 모를 수도 있고, 진행 중인 세션 내의 유저 행동 기록만을 사용해야 할 수도 ⇒ "따라서 한 세션에서 제한된 행동 기록들을 모델링하고 그에 맞춰 추천을 생성해야한다."

기존 모델

• 이전의 RNN 계열의 모델에서는 유저의 선호도를 반영하는 user representation이 따로 존재하지 않고, RNN의 hidden vector를 user representation으로 삼고 다음 아이템을 예측해 왔다. 그러나 각 세션은 user-specific하지 않고, 세션 클릭과 관련된 유저의 행동은 대부분 한정되어 있다. ⇒ 각 세션에서 user representation을 정확하게 추정하는 것은 어렵다.

• 기존 모델들은 연속적으로 선택되는 아이템들의 single-way Transition을 모델링하고, 세션 내의 다른 여러 아이템들 간의 복잡한 Trainstion은 무시한다. ⇒ 멀리 떨어진 아이템들 사이의 복잡한 Transition은 간과되어 왔다.

1.2 SR-GNN (Session-based Recommendation with Graph Neural Networks)

Graph Neural Networks를 사용한 Session-based 추천시스템 기존 모델들의 단점들을 보완하기 위해 본 논문에서 제안된 모델

• Graph Neural Networks를 통해 아이템 간의 관계를 파악하고, 아이템 임베딩에 대해 정확한 값을 만들어낸다 이는 Markov Chain & RNN 기반 모델 같은 전통적인 시퀀셜 모델에서는 구현되기 어렵다.
• 아이템 임베딩에 대한 정확한 값들을 기반으로 global preference와 current interest를 구하여 예측에 사용한다.
• User-specific 하지는 않지만, 해당 세션의 시퀀스가 반영된 임베딩이 들어가기 때문에 session-specific하게 예측할 수 있다.

2. Related Works

2.1 Conventional recommendation methods

1) Matrix Factorization

Target 값(implicit, explicit)을 저차원 아이템 임베딩 행렬과 임베딩 행렬로 분해하는 방법론

• 세션 기반 추천에서는 적절하지 못하다. → 왜냐하면 유저 선호도 일부가 positive 클릭에 의해서만 제공되며, 아이템 시퀀셜 순서를 고려하는데 어려움이 있고, 단지 마지막 클릭을 바탕으로 예측을 수행하기 때문

2) Markov chain-based method

Transition probability를 바탕으로 아이템 간의 관계를 정의하고 그 관계로부터 행렬 분해를 하는 방법론

• 이 모델의 가장 큰 결점은 이 모델들이 과거 구성요소들을 독립적으로 결합한다는 것이다. → 이러한 독립가정은 너무 강력하기 때문에 예측 정확도를 국한 시킨다.

2.2 Deep learning-based recommendation methods

1) Improved recurrent neural networks for session-based recommendations

: 유저 행동의 시간적 변화를 고려하고 적절한 data augmentation기법을사용하여 순환 모델의 성능을 높임.

2) When recurrent neural networks meet the neighborhood for session-based recommendation

: 시퀀셜 패턴과 동시에 발생 신호를 혼합하기 위해 이웃 기반 기법과 순환기법을 결합함.

3) 3D convolutional networks for session-based recommendation with content features

: 추천을 수행하기 위해 3c CNN을 사용하여 아이템 카테고리 & 설명 같은컨텐츠 features와 세션 클릭을 통합함.

4) List-wise DNN

: 각 세션 내 제한된 유저 행동을 모델링하고, 각 세션에 대한 추천을 수행하기 위해 List-wise 랭킹 모델을 사용함.

5) NARM(A Neural Attentive Recommendation Machine with an encoder-decoder architecture)

: 유저의 시퀀셜 행동의 features와 주요 목적을 포착하기 위해 RNN 어텐션 메커니즘을 사용함.

6) STAMP(Short-Term Attention Priority model)

: 유저의 일반적인 흥미와 현재 흥미를 효율적으로 포착하기 위해 제시됨.

2.3 Graph Neural Networks

1) Graph Neural Nerworks

• 그래프 구조에서 사용하는 인공 경망이다.
• 인공 신경망들을 보통 벡터나 행렬 형태로 input이 주어지는 데 반해서 GNN의 경우 input이 그래프 구조라는 특징이 있다.
• 관계, 상호작용과 같은 추상적인 개념을 다루기에 적합하다.
• 일반적인 그래프는 𝐺 = (𝑉, 𝐸)로 정의하며 𝑉는 점 집합이고 𝐸는 두 점을 잇는 선 집합이다. 아래 그래프는 다음과 같이 정의할 수 있다. 𝐺 = ( 1,2,3 ,{ 1,2 , 2,3 ,{1,3}})

  2) Gated Graph Neural Networks

• GNN의 수정 버전으로 노드 벡터를 업데이트할 때 GRU cell을 이용한다.
• 시간 경과에 따른 역전파(BPTT, Back-Propagation Through Time)를 사용하여 Gradients를 계산한다.

3. The proposed Methods

3.1 The workflow of the proposed SR-GNN

세션 기반 추천은 장기 선호도 프로필 접근 없이 유저의 현재 시퀀셜 세션 데이터(current sequence session data)만을 기반으로 유저가 다음에 클릭할 아이템이 무엇인지 예측하는 것에 초점을 둔다.

3.2 Notations

3.3 Constructing Session Graphs

각 세션 시퀀스 𝑠 는 directed graph 𝒢𝑠 = (𝒱𝑠, ℰ𝑠) 로 표현된다. 각 노드들은 아이템 $$v_{s,i}$$ ∈ 𝑉를 의미하고, 각 Edge $$(v_{s,i-1},v_{s,i}) \in$$ ℰ𝑠는 유저가 $$(v_{s,i-1})$$ 다음에 $$(v_{s,i})$$를 클릭했다는 의미이다.

• 아이템들이 한 시퀀스에서 반복적으로 등장할 수 있기 때문에 각 edge를 정규화된 가중치로 할당한다. 가중치: edge의 발생정도 / edge의 시작 노드의 outgree(출력차수)
• 모든 아이템 𝑣 ∈ 𝑉을 통합된 임베딩 공간에 임베딩하며, 노드 벡터 𝑣 ∈ 𝑅 𝑑는 GNN을 통해 학습된 아이템 𝑣의 latent vector를 의미한다. (𝑑는 차원)
• 노드 벡터에 기반하여 각 세션 𝑠는 임베딩 벡터 𝑠로 표현될 수 있다. 임베딩 벡터 𝑠는 해당 그래프에서 사용된 노드 벡터로 구성된다.

  3.4 Learning Item Embedding on Session Graphs

  
• Parameter*
• Update function for the node $$v_{s,i}$$ of graph 𝒢s*
• A example of a session graph and the connection matrix $$A_s$$*

  3.5 Generating Session Embeddings

  
• 모든 세션 그래프를 gated GNN에 공급한 후에 모든 노드 벡터를 얻는다.
• 각 세션을 embedding vector $$s \in R^d$$로 표현하기 위해 다음을 고려한다.
• session $$s=[v_{s,1},v_{s,2},...,v_{s,n}]$$

  3.6 Making Recommendation and Model Training

  
• loss function: cross-entropy $$y$$는 ground truth 아이템의 one-hot encoding vector
• 마지막으로 BPTT(Back-Propagation Through Time)를 사용해서 SR-GNN을 학습시킴
• 보통 세션 추천 시스템에서, 대부분의 세션은 상대적으로 짧은 길이를 가진다는 것을 유의해야함. 따라서 오버피팅을 예방하기 위해 비교적 적은 수의 훈련 스템을 선택하는 것을 제안

4. Experiments and Analysis

4.1 Datasets

• Yoochoose, Diginetica dataset: e-commerce 웹사이트에 유저들의 클릭 기록

• 세션 길이 1짜리는 제거

• Cold-start problem 방지를 위해 최소 등장 횟수 5회로 설정

• Input 세션 $$s=[v_{s,1}, v_{s,2},..., v_{s,n}]$$의 경우 시퀀스와 레이블 시리즈를 다음과 같이 생성한다.

  4.2 Baseline Algorithms

  제시된 모델의 성능을 평가하기 위해 아래와 같은 대표적인 베이스라인들과 비교한다.

• POP & S-POP: 훈련집합과 현재 세션에서 각각 빈번하게 등장한 top-N개의 아이템들을 추천

• Item-KNN: 세션에서 이전에 클릭된 것과 유사한 아이템을 추천 (유사도는 세션 벡터 사이의 코사인 유사도로 정의)

• BPR-MF: SGD(Stochastic Gradient Descent)를 통해 Pairwise 랭킹 목적 함수 최적화

• FPMC: 마르코프 연쇄 기반 시퀀셜 예측 기법

• GRU4REC: 세션 기반 추천에 대해 유저 시퀀스를 모델링하는 RNN을 사용

• NARM: 유저의 핵심 목적과 시퀀셜 행동을 포착하는 어텐션 메커니즘 RNN을 사용

• STAMP: 유저의 일반적인 선호도와 현재 세션에서의 마지막 클릭을 통해 현재 관심사를 포착

  4.3 Evaluation Metrics

• P@20 (Precision): 예측 정확도 측정치로 널리 사용됨. top-20 아이템들 중에서 정확하게 추천된 아이템의 비율을 나타냄.

• MARR@20 (Mean Reciprocal Rank): 정확하게 추천된 아이템의 역순위 평균임. 역순위가 20을 초과할 때는 0으로 설정됨. MRR 측청치는 추천 랭킹 순서를 고려함. → MRR 값이 크면 TOP 랭킨 리스트에 정확한 추천이 나타남.

  4.4 Parameter Setup

• 이전 모델들 (NARM, STAMP)에 따라 두 데이테 셋에 대해 latent vector의 차원을 $d=100$으로 설정함

• validation set을 통해 하이퍼파라미터 튜닝

• 모든 파라미터들은 평균=0, 표준편차=0.1을 가지는 가우시안 분포를 사용하여 초기화됨.

• mini-batch Adam optimizer

• 초기 학습률 0.001, 3 Epochs 후에 0.1씩 감소

• Batch 크기 = 100

• L2 규제화 = $$10^{-5}$$

  4.5 Comparison with Baseline Methods

  

• POP&S-POP은 반복적으로 동시에 발생한 아이템 혹은 연속적인 아 이템만을 기반으로 추천을 수행하는 단순한 알고리즘으로 성능이 상대 적으로 좋지 않음.

• 그러나 S-POP은 최근 세션들에서 인기 아이템을 고르기에 BPR, FPMC보다 성능이 좋음 ⇒ 세션의 contextual한 정보가 중요함을 알 수 있음.

• GRU4REC나 NARM은 RNN 모델을 사용하여 유저의 general interest를파악하려 했기에 성능이 좋아짐.

• 그러나 STAMP는 마지막 아이템에 대해 강조함으로써 short-term interest를 파악했기에 성능이 더 좋아짐.

• SR-GNN은 세션만 보는 것이 아니라 아이템들이 가지는 관계를 전체적으로 파악하면서 preference를 이해하려 했음.

• 또한 어텐션 메커니즘을 통해 아이템 간의 관계를 좀 더 잘 파악하도록 설계됨.

  실험에 따르면 본 논문에서 제안된 SR-GNN 기법이 P@20&MRR@20의 관점에서 봤을 때 모든 데이터 셋에서 가장 좋은 성능을 보였다.

  4.6 Comparison with Variants of Connection Schemes

  세션에서의 유저 행동은 제한적이기 때문에 각 세션 그래프 간의 또 다른 형태의 연결을 제시한다.

  SR-GNN

  시퀀스 별로 그래프 구성

  SR-GNN-NGC

  전체 시퀀스를 두고 한 번에 global graph를 구성

  SR-GNN-FC

  시퀀스 별로 시작 노드와 끝 노드만을 잇는 방식으로 구성

• 세 연결 방식 모두 STAMP&NARM 모델보다 더 좋거나 거의 동일한 성능을 달성했다.

• SR-GNN과 비교하여 NGC: 최근에 발생한 세션에 집중하지 못하므로 short-term이 중요한 해당 데이터 셋에서는 성능이 저하됨. FC: 큰 차이는 없지만 SR-GNN보다 성능이 조금 더 안 좋음. 이는 아이템의 등장 순서가 매우 중요하고 아이템 간의 관계 사이에 다른 아이템의 존재가 중요할 수 있음을 시사함. → 예를 들어 유저가 웹 사이트를 검색할 때 다음 페이지를 본 경우A→B→C, A와 C 사이의 직접 연결이 부족하기 때문에 중간 페이지 B가 없이 A 다음에 C 페이지를 추천하는 것은 적절하지 않을 수 있다.

  4.7 Comparison with Different Session Embeddings

  SR-GNN

  $$s_l+s_g$$ local embedding과 global embedding 모두 사용

  SR-GNN-L

  오직 local embedding($$s_l$$)만 사용

  SR-GNN-AVG

  평균 pooling을 사용한 global embedding($$s_g$$) 사용

  SR-GNN-ATT

  어텐션 메커니즘을 사용한 global embedding($$s_g$$) 사용

• local embedding과 global embedding을 모두 사용한 SR-GNN이 가장 좋은 결과 → 이는 장기 선호도를 이용한 현재 세션에서의 관심사를 명시적으로 통합하는 것에 대한 중요성을 보여줌.

• ATT가 두 번째로 좋은 성능을 보임. → 행동 시퀀스들의 노이즈를 잡아내는 것이 중요하며 중요한 행동을 파악하는 것이 중요함을 알 수 있음. 또한 어텐션 메커니즘이 장기 선호도를 구축하기 위해 세션 데이터에서 중요 행동을 추출하는 데 도움을 준다는 것을 보여줌.

• L버전도 성능이 좋음. → current interest도 전체 시퀀스에서 알 수 있는 장기 선호도만큼 중요함을 알 수 있음.

  4.8 Analysis on Session Sequence Lengths

• 서로 다른 길이의 세션에 대처하기 위해 세션 길이 별 분석을 진행한다.

• 평균 길이5를 기준으로 short session과 long session으로 구분한다.

• SR-GNN은 서로 다른 세션 길이를 가진 두 가지 데이터 셋에서 안정적인 성능을 보인다.

• NARM과 STAMP 모두 RNN 계열의 모델을 기반으로 하기에 길이가 긴 시퀀스에 대해서는 성능이 저하되었다

5. Conclusions

• 세션 기반 추천은 유저 선호도와 기록 내역을 얻기 어려울 때 필수적이다.
• 본 논문은 그래프 모델로 세션 시퀀스를 표현하기 위한 새로운 아키텍처를 제시하였다.

  SR-GNN • 세션 시퀀스 아이템 간의 복잡한 구조와 Transition을 고려할 뿐만 아니라 유저의 다음 행동을 더 잘 예측하기 위해 장기 선호도와 현재 세션에서의 관심사를 결합하여 사용하였다. • 종합적인 실험들은 제시된 알고리즘이 다른 최신 기법들보다 일관적으로 좋은 성능을 내는 것을 입증하였다.

| 참고자료 http://dsba.korea.ac.kr/seminar/?mod=document&uid=75 https://soobarkbar.tistory.com/184 https://velog.io/@jkl133/SR-GNN-ing https://medium.com/watcha/gnn-%EC%86%8C%EA%B0%9C-%EA%B8%B0%EC%B4%88%EB%B6%80%ED%84%B0-%EB%85%BC%EB%AC%B8%EA%B9%8C%EC%A7%80-96567b783479

MATRIX FACTORIZATION TECHNIQUES FOR RECOMMENDER SYSTEMS

Yehuda Koren, Yahoo Research Robert Bell and Chris Volinsky, AT&T Labs—Research(2009)

1. Recommender System Strategies

content filtering: 사용자나 제품에 대한 profile 먼저 생성한다. ex.) 관객 - (인구통계적 사실, 설문 결과) 영화 - (장르, 인기도)

collaborative filtering approach: profile이 없는 상태에서 아이템이나 유저에 대한 필터링하는 방법(과거 구매 이력, 제품평가점수, browsing history 등 implicit data 활용)

하지만, 기존 평가 자료 존재하지 않거나 신규 유저가 나타남으로 인해 cold start 문제가 존재한다.

Neighborhood method: 아이템끼리의 관계, 사용자들끼리의 관계 계산. 거리가 가까운 것을 추천한다

• item oriented(아이템끼리의 관계 산출): 전제:특정 아이템들의 점수가 비슷하다면 그 아이템끼리는 가까운 위치에 있을 것이다.

• user oriented(유저들끼리의 관계 산출): 전제: 비슷한 영화를 동일한 점수를 매긴 사용자들끼리 선호 경향이 비슷할 것이다. (like minded user)

Latent factor method: 전제: 아이템에게 주는 rating 점수에는 패턴이 있을 것이다. 패턴을 찾아내서 하나의 factor로 추출내고 factor score을 중심으로 근거리 추정하여 추천하는 방법이다.

2.Matrix Factorization method

Latent model은 Model Factorization을 이용한다.

보통 추천시스템은 위 형태의 인풋 데이터 세트를 사용하지만 이 explicit feedback데이터는 sparsity issue 존재한다.

Matrix Factorization은 implicit feedback을 추론하므로 이 sparsity issue 극복 가능하다.(이 논문에서는 implicit data로 Purchase history, browsing history, search pattern, mouse movement 등을 활용했다.)

3. Basic Factorization model

SVD(Singular Value Decomposition) 이용 시 문제점:

• Missing value가 많으면 SVD 이용이 곤란하다. Matrix에 대한 정보가 충분하지 않으면 정의하기 곤란하거나 Overfitting 위험하기 때문이다. 기존의 해결방식은 missing value imputation을 해서 문제를 해결하는데 데이터가 많아지면 매우 힘든(비효율적) 방법이 될 수 있고 부정확한 imputation은 데이터를 왜곡시킬 위험이 있다

-> 최근에는 Regularized modeling을 통해 해결한다.

• Factor vector을 학습시키기 위해 regularized squared error를 최소화

                                                           cf. k는 set of the (u,i) pairs       R은 rating(training set)

• 학습한 파라미터를 regularizing하므로 관찰된 데이터에 overfitting 되는 것을 극복한다.

• 상수 ʎ는 regularization의 정도를 조절하는 상수다.

4.Learning Algorithms

Stochastic gradient descent

• r_ui를 예측하고 예측 에러를 계산한다.
• Gradient의 반대 방향에서 r에 비례하는 양만큼 파라미터를 수정한다.

Alternating least squares

• q_j와 p_u는 unknown parameter이기 때문에 앞의 에러 최소화 식은 convex 형태가 아니다.
• Unknown parameter 중 하나를 fix하면 이 최적화문제는 2차식(quadratic)이 된다.
• ALS 테크닉이란 q_i와 p_u를 교대로 fixing하는 방식을 의미한다.
  • p_u를 fix하면 least-square 문제를 해결하는 방식으로 q_i를 재계산한다.
  • 보통은 SGD가 ALS보다 빠르고 용이하나 다음 두 경우에는 ALS가 우월하다.

5. Adding Biases

Collaborative filtering 대비 MF의 장점 : 다양한 데이터와 기타 application specific 요구사항을 반영해내는 유연성이 있다.

많은 경우 관찰된 변량은 baises 또는 intercepts와 관련이 있다. 예를 들어, 어떤 user들은 더 높은 점수를 주는 경향이 있고, 어떤 item은 좀 더 좋은 점수를 받는 경향이 있는데 이것이 어떤 제품이 더 좋다는 인식을 만들어냈다. 따라서 q_iTp_u형태로만 전체 rating 값을 설명하는 것은 현명하지 않다. (개선된 r_ui : Global average + item bias + user bias + user item interaction )

Squared error function minimizing

• Biases는 observed signal을 잡아내기 때문에 정확한 모델링이 결정적 사항이다.

6. Additional Input Sources

Cold start problem의 해결: User의 explicit ratings에 관계 없이 구매 이력, 브라우징 기록 등 추가 정보 이용

• 모든 signal source를 통합해서 아래와 같이 표현한다.
• 이때 user표현이 더 강화된 것을 알 수 있다.

7. Temporal Dynamics

변화무쌍한 현실 세계

• 신제품이 출시되면 제품/브랜드에 대한 인식 및 인기는 지속적으로 변화한다.
• 소비자의 선호경향도 지속적으로 변화한다.

모델링

• Item biases b_i(t) : Item popularity의 변화를 시간의 함수로 표현
• User biases b_u(t): Natural drift in a user’s rating을 시간의 함수로 표현
• User preferences p_u(t): user와 item의 상호작용이므로 user preference도 시간에 따라 변화하는 함수로 표현

8. Inputs with varying confidence levels

유의수준도 변화무쌍

• 대규모 광고 집행의 단기적 영향이 있을 수 있다.
• 의도적으로 rating을 높거나 낮게 주는 소비자의 문제가 있을 수 있다.
• 소비자 선호 경향을 추론하는 방식의 추천시스템의 문제(implicit feedback)가 있을 수 있다.

유의수준을 모델링에 반영

• Confidence score을 병기하는 것이 바람직하다.

9. Netflix Prize Competition

넷플릭스 공모전(2006년 실시)

• 50만명 이상 소비자가 17,000 영화에 평점(5점 척도)을 준 1억 건의 데이터 셋
• 테스트셋 3백만 건에 대한 rating 예측치를 제출하면 넷플릭스는 RMSE 계산
• 10% 이상 성능을 개선시키면 10억, 아무도 없으면 1등에게 5만 달러
• 182개 국에서 28,000팀 출전

저자가 Matrix Factorization으로 1등한 내용

• MF로 dimension(factor vector)을 발견
• X축: 저속 comedy & horor, 남성/청소년 타겟 Drama & Comedy, 심각, 강한 여성
• Y축: 독립 영화, 수상작 vs. 정형화된 주류 영화
• 저속 & 독립영화가 가깝게 포지셔닝
• 심각한 여성주도 영화 & 주류 영화가 가깝게 포지셔닝

모델링 성과 분석

• 파라미터가 많아질 수록 정확도 증가
• 모델이 복잡할수록 정확도 증가
• Temporal component가 특히 중요

총정리

• 기존의 nearest-neighbor보다 우월했다
• Multiple formula of feedback, temporal dynamics, confidence level과 같은 다양한 측면을 반영할 수록 성능이 좋아졌다.

Neural Graph Collaborative Filtering (2019, ACM)

1. Introduction

Recommender system은 크게 Content-based Filtering과 Collaborative Filtering으로 나눌 수 있습니다. 본 강의는 Collaborative Filtering Model을 중심으로 학습할 예정입니다. Collaborative Filtering Model의 일종인 Latent Factor Mdoel의 여러 방법들 중 하나로 Matrix Factorization이 존재합니다. Matrix Factorization은 latent factor간의 내적, 즉 선형결합을 통해 Collaborative Signal(유저 - 아이템 상호작용)을 나타내기 때문에 복잡한 구조의 Signal을 알아내기 어렵습니다. 또한 새로운 유저가 등장하면 저차원 공간에 이를 표현하기 어렵다는 단점이 존재합니다. 그래서 등장한 모델이 바로 Neural Collaborative Filtering 모델입니다.
Neural Collaborative Filtering Model은 Deep Neural Network를 사용하여 유저-아이템간 상호작용을 학습합니다. Neural Network를 사용하기 때문에 비선형적인 Collaborative Signal을 표현할 수 있다는 것이 Matrix Factorization과의 차이점입니다. 그러나 몇몇 연구자들은 Neural Collaborative Filtering(이하 NCF)조차도 유저-아이템간 상호작용을 나타내기에 아직 부족하다며 새로운 모델을 제안합니다. 이 모델은 바로 Neural Graph Collaborative Filtering(이하 NGCF) 모델입니다.
일반적으로 CF 모델은 유저와 아이템을 벡터로 변환하는 Embedding과정과, 이를 기반으로 사용자의 historical interaction(구매 혹은 클릭)을 예측하는 Interaction Modeling로 구성되어 있습니다.
기존의 CF 모델들은 유저-아이템간 상호작용을 명시적으로 사용하지 않았습니다. 즉, 모두 Embedding에 유저-아이템간 상호작용을 반영하지 않았습니다. 단지 유저와 아이템 각각의 descriptive feature만을 embedding에 사용했습니다.

이러한 기존 CF 모델의 한계점을 극복하기 위해 NGCF 모델에서는 High-order Connectivity라는 새로운 특성을 모델에 반영하고자 합니다.

• Notation
  • $u_{i}$ : $i$번째 유저
  • $i_{j}$ : $j$번째 아이템
• 기존 NCF Model
  • $u_{1}$이 $i_{1}$을 선택 → 관계 종료
  • 1차적인 관계
• NGCF Model
  • 유저와 아이템 간의 여러 관계를 그래프적으로 표현
  • 여러 관계 = High-order → Sequential한 관계라고도 표현

• NGCF Model의 High-order connectivity
  • $u_{1} ← i_{2} ← u_{2}$ : $u_{1}$과 $u_{2}$ 간 유사성 존재 (두 사용자 모두 i_{2}와 상호작용을 했기 때문)
  • $u_{1} ← i_{2} ← u_{2} ← i_{4}$
    : $u_{1}$은 $i_{4}$를 사용할 가능성이 있음 ($u_{1}$은 $u_{2}$와 유사)
  • $u_{1}$은 $i_{5}$보다 $i_{4}$를 선호할 것 : $u_{2}$ 뿐만 아니라, $u_{1}$와 유사한 또 다른 유저 $u_{3}$도 $i_{4}$를 사용하기 때문

이처럼 High-order Connectivity에서 Collaborative Signal를 표현하기 위해 GNN의 아이디어를 embedding propagation layer에서 실현합니다.

2. Methodology

• 모델 구조 기존 CF 모델들과 다르게 NGCF는 Embedding Propagation Layer를 가집니다.

• GNN GNN은 Node(ex. 사용자)와 Edge(ex.관계) 등으로 표현되는 graph형태의 데이터를 모델링하기 위한 네트워크입니다. 그래프 데이터는 기존 정형, 비정형 데이터와 다르게 유클리드 공간에 벡터화할 수 없다는 성질이 있습니다. 따라서 이를 기존 ML 알고리즘에 넣기 위해 추가적인 Network를 활용하여 벡터 형태의 값을 도출하는 데, 이 때 사용하는 네트워크를 Aggregation Function이라고 합니다. 본 논문에서는 Embedding Propagation Layer가 그와 같은 역할을 한다고 볼 수 있습니다.

1) Embedding Layer

처음 Input data로는 유저와 아이템간 상호작용이 반영되지 않은 유저, 아이템 각각의 Embedding이 사용됩니다.

• $E = [e_{u_{1}}, ..., e_{u_{N}}, e_{i_{1}}, e_{i_{M}}]$ : 임베딩 matrix
• $e_{u_{N}}$ : N번째 사용자의 임베딩 벡터
  

2) Embedding Propagation Layers

Input 값으로 앞서 Embedding layer의 output인 유저, 아이템의 임베딩 벡터가 사용됩니다. 논문에서는 First-order propagation → High-order propagation 순으로 설명이 진행되고 있으므로, 동일한 순서로 리뷰를 진행하도록 하겠습니다.

• First-order propagation : 첫번째 Embedding Propagation Layer에서 발생하는 전파
• High-order propagation : 두번째 ~ $l$번째 Embedding Propagation Layer에서 발생하는 전파

[First-order propagation]

First-order propagation을 구성하는 두 가지 주요 작용은 Message Construction과 Message Aggregation입니다.

a. Message Construction Message Construction은 propagation layer에서 전파될 메시지를 생성해내는 과정을 의미합니다. 그래프 데이터에서 Connected user-item pair $(u,i)$를 도출해내고, 두 노드의 정보를 이용하여 전파될 정보를 의미하는 Message Embedding을 도출합니다.

• function $f$의 input
  • $e_{i}$ : item의 embedding
  • $e_{u}$ : user의 embedding
  • $p_{ui}$ : decay factor (매 전파마다 전파되는 메시지가 감가상각 되는 것을 반영해주는 coefficient)

또한 Message Construction의 function $f$는 다음과 같은 구조를 가집니다.
기존 GCN(GNN의 일종, Graph Convolutional Network)과 다르게 $e_{i}$ (자기자신) 에 대해서만 고려하지 않고, 추가적으로 user-item interatcion을 메시지에 인코딩 합니다.
이 interaction 때문에 메시지는 두 임베딩 사이의 관련성 (affinity)에 의존하고, 유사한 아이템으로부터 더 많은 메시지를 전달할 수 있게 됩니다. (결과적으로 성능 향상이 이루어집니다.)

• $|N_{u}|$ : user $u$의 이웃들의 수
• $|N_{i}|$ : item $i$의 이웃들의 수
• $W$ : trainable matrix
  

b. Message Aggregation
Message Aggregation은 $u$의 이웃노드로부터 전파된 메시지들을 모아(aggregate) $u$의 임베딩을 refine하는 과정을 의미합니다. 이 때 Aggregation function으로 $LeakyReLU$를 활용하며, 이웃노드로부터의 메시지 뿐만 아니라 본래 자신에 대한 정보인 $m_{u ← u}$까지 input으로 넣습니다. 이를 통해 $e_{u}^{(1)}$ ($u$에 대한 첫 임베딩 레이어의 벡터 표현)을 도출합니다.

[High-order propagation]
first-order connectivity에서 변환된 벡터 표현을 가지고, high-order connectivity 정보를 탐색하기 위해 더 많은 embedding propagation layers를 쌓습니다(stacking).
이 과정을 통해 사용자와 아이템 사이의 relevance score를 예측할 수 있으며, $l$ 개의 embedding propagation layer를 쌓으면, 유저 노드는 $l$-hop 이웃으로부터 전파된 메시지를 받을 수 있습니다. 이 때 사용되는 함수 식은 다음과 같습니다.

• $e_{u}^{l}$ : $u$에 대한 $l$번째 임베딩 레이어의 벡터 표현
• $e_{u}^{l} = LeakyReLU(m_{u←u}^{(l)} + \sum_{i \in N_{u}}m_{u←u}^{(l)})$
• $m_{u←i}^{(l)} = \rho_{ui}\big(W_{1}^{(l)}e_{u}^{(l-1)} + W_{2}^{(l)}(e_{i}^{(l-1)}\odot e_{u}^{(l-1)})\big)$
• $m_{u←u}^{(l)} = W_{1}^{(l)}e_{u}^{(l-1)}$

다음 그림의 빨간선이 $u_{1}$의 임베딩 벡터를 찾아나가는 과정이므로 참고하시면 될 것 같습니다.

3) Model Prediction

$l$개의 embedding propagation layer를 거친 후 나온 output은 ${e_{u}^{(1)}, ..., e_{i}^{(l)} }$ 입니다.
각각의 임베딩들을 concatenate함으로써 최종 유저에 대한 임베딩을 구성합니다.

• $e_{u}^{*} = e_{u}^{(0)}\vert\vert ... \vert\vert e_{u}^{(L)}$
• $e_{i}^{*} = e_{i}^{(0)}\vert\vert ... \vert\vert e_{i}^{(L)}$

concatenate를 사용했기 때문에 파라미터가 없어 연산이 단순하다는 장점이 있으며, 최신 GNN 연구를 통해 layer-aggregation 방식으로 꽤 효과적임을 검증받았습니다.
결론적으로, Prediction Layer의 최종 output은 다음과 같습니다.

• $\hat{y}{NGCF}(u, i) = (e{u}^{})^{T} e_{i}^{}$

4) Etc...

** [Loss Function] **

• Pairwise BPR Loss
  : 유저의 선호를 더 잘 반영하는 observed interaction에 높은 점수 부여 (vs unobserseved interaction)
• Optimizer : Adam

** [Message and Node Dropout] **

** a. Message Dropout **

• High-order connectivity에서 전파되는 메시지를 drop
• 최종 $l$번째 전파 레이어에서는 부분적인 메시지들만이 표현 refine과정에 영향을 줌

** b. Node Dropout **

• 특정 노드를 임의로 차단해서, 해당 노드에서 나가는 메시지를 모두 차단하는 방법

3. Evaluation / Conclusion

Evaluation

3개의 벤치마크 데이터셋에 대해 실험을 한 후, 3개의 Research Question에 답하는 것을 중점으로 논문은 진행되고 있습니다.

Recall과 ndcg를 metric으로 사용했습니다.

** RQ1. SOTA CF 방법론들에 비해 NGCF는 어떤 성능을 내는가? ** NGCF는 모든 데이터셋, 평가지표에서 가장 우수한 성능을 보였습니다. 또한 high-connectivity를 모델 자체가 아닌, training data를 증가시키는 것에만 사용한 HOP-Rec 모델에 비해 NGCF-3의 성능이 좋았다는 사실을 통해, 임베딩 함수에서 명시적으로 Collaborative Signal을 인코딩하는 것이 성능을 개선했음을 알 수 있습니다.

** RQ2. 하이퍼파라미터들은 NGCF의 성능에 어떤 영향을 주는가? **

a. 임베딩 전파레이어의 개수
전반적으로 전파 레이어에서 레이어 개수를 높일수록 성능이 개선되었으나, NGCF-4의 경우 일부 데이터에서 과적합되었습니다.
이를 통해, 3개의 전파레이어를 사용하는 것이 가장 적합하다는 것을 알 수 있었습니다.
또한 레이어의 개수와 상관없이 NGCF는 다른 모델에 비해 더 성능이 좋았는데, 이를 통해 high-order connectivity를 명시적으로 모델링하는 것이 추천 task에서 성능 향상에 크게 기여한다는 것을 알 수 있습니다.

b. 하이퍼 파라미터
(생략)

** RQ3. 벡터 표현이 어떻게 high-order connectivity에서 향상이 이루어지는가? **

임베딩 전파가 임베딩 공간에서 표현학습을 어떻게 증진시키는지 TSNE를 이용해 확인했습니다. 유저와 관련된 임의의 아이템을 의미하는 ★을 6개 추출하였습니다. 왼쪽그림은 MF를, 오른쪽 그림은 NGCF-3의 경우를 의미하는데, NGCF-3을 이용했을 때 같은 색의 ★과 ●이 거리상으로도 가까이 위치하고, 클러스터를 잘 형성하고 있었습니다. 이를 통해 high-order connectivity를 통해 벡터 표현이 항상되었음을 확인했습니다.

Conclusion

결론에서는 NGCF에 대해 요약 설명하고, 후속 연구를 제시하며 논문이 마무리 됩니다.

참고 문헌

• https://towardsdatascience.com/an-introduction-to-graph-neural-network-gnn-for-analysing-structured-data-afce79f4cfdc
• https://velog.io/@ysn003/%EB%85%BC%EB%AC%B8-Neural-Graph-Collaborative-Filtering#running-example
• https://joyae.github.io/2020-09-02-nDCG/
• https://towardsdatascience.com/collaborative-filtering-and-embeddings-part-1-63b00b9739ce
• https://pongdangstory.tistory.com/511

[코드 출처] (https://github.com/hexiangnan/neural_collaborative_filtering)

Neural Collaborative Filtering의 저자가 직접 구현한 코드이다.

NeuMF.py

• ncf 모델 구현되어있음. without pre-training / with pre-training 두가지로 미리 학습된 weight 를 사용할 수도 있음.

Dataset.py

• 데이터셋을 불러오는 클래스 정의되어 있음

evaluate.py

• Hit_Ratio, NDCG 를 구하는 함수

GMF.py

• GMF가 구현되어있다. pre-train된 weights를 불러올 때 사용된다.

MLP.py

• MLP가 구현되어있다. pre-train된 weights를 불러올 때 사용된다.

GMF.py

• $\textbf{p}u =\textbf{P}^{T}\textbf{v}^{u}{U}$ : user latnet vector(임베딩 행렬과 one hot encoding vector를 곱한 것)

• $\textbf{q}{i} = \textbf{Q}^{T}\textbf{v}^{i}{I}$ : item latent vector(임베딩 행렬과 one hot encoding vector를 곱한 것)

• $\phi_{1} (\textbf{p}{u}, \textbf{q}{i}) = \textbf{p}{u} ⊙ \textbf{q}{i}$ : user latent vector와 item latent vector의 element wise product

• ⊙ : element wise product

• $\hat{y}{ui} = a{out}(\textbf{h}^{T}(\textbf{p}{u} ⊙ \textbf{q}{i}))$ : 위의 값을 weight, sigmoid function 적용한 것

• $\textbf{h}$ : output layer 의 weight

• $a_{out}$ : sigmoid 함수

• $\textbf{h}$ 가 모두 동일하게 1이라면 MF가 되는 것임 MF는 GMF의 특정한 경우이다.

• $a_{out}$ 가 비선형 함수라면 결과도 비선형이 된다.

def get_model(num_users, num_items, latent_dim, regs=[0,0]):
    # Input variables
    user_input = Input(shape=(1,), dtype='int32', name = 'user_input')
    item_input = Input(shape=(1,), dtype='int32', name = 'item_input')

    MF_Embedding_User = Embedding(input_dim = num_users, output_dim = latent_dim, name = 'user_embedding',
                                  init = init_normal, W_regularizer = l2(regs[0]), input_length=1)
    MF_Embedding_Item = Embedding(input_dim = num_items, output_dim = latent_dim, name = 'item_embedding',
                                  init = init_normal, W_regularizer = l2(regs[1]), input_length=1)   

    # Crucial to flatten an embedding vector!
    user_latent = Flatten()(MF_Embedding_User(user_input))
    item_latent = Flatten()(MF_Embedding_Item(item_input))

    # Element-wise product of user and item embeddings 
    predict_vector = merge([user_latent, item_latent], mode = 'mul')

    # Final prediction layer
    #prediction = Lambda(lambda x: K.sigmoid(K.sum(x)), output_shape=(1,))(predict_vector)
    prediction = Dense(1, activation='sigmoid', init='lecun_uniform', name = 'prediction')(predict_vector)

    model = Model(input=[user_input, item_input], 
                output=prediction)

    return model

MLP.py

• $\textbf{p}_u$ 와 $\textbf{q}_i$의 관계성을 학습하기 위해 mlp사용

• $\textbf{z}{1} = \phi{1}(\textbf{p}{u}, \textbf{q}{i}) = {\textbf{p}{u} \choose \textbf{q}{i}}$ : concat(user, item)

• $\phi_{2}(\textbf{z}1) = a{2}(\textbf{W}_{2}^{T} \textbf{z}_1 + \textbf{b}_2), ...$ : wx+b 형태의 weight와 bias 선형결합

• $\hat{y}{ui} = \sigma(\textbf{h}^{T}\phi{L}(\textbf{z}_{L-1}))$ : 마지막 layer weight 적용 후, 활성화 함수

• 본 논문에서는 sigmoid, tanh 보다 ReLU가 성능이 더 좋았다고 함

• ReLU 사용으로 비선형성가진다.

• 레이어의 노드수를 점점 줄여나가며 구성해서 추상적인 피쳐를 학습할 수 있다.

• dense(64) -> dense(32) -> dense(16) -> dense(8)

  def get_model(num_users, num_items, layers = [20,10], reg_layers=[0,0]):
    assert len(layers) == len(reg_layers)
    num_layer = len(layers) #Number of layers in the MLP
    # Input variables
    user_input = Input(shape=(1,), dtype='int32', name = 'user_input')
    item_input = Input(shape=(1,), dtype='int32', name = 'item_input')
  
    MLP_Embedding_User = Embedding(input_dim = num_users, output_dim = layers[0]/2, name = 'user_embedding',
                                  init = init_normal, W_regularizer = l2(reg_layers[0]), input_length=1)
    MLP_Embedding_Item = Embedding(input_dim = num_items, output_dim = layers[0]/2, name = 'item_embedding',
                                  init = init_normal, W_regularizer = l2(reg_layers[0]), input_length=1)   
  
    # Crucial to flatten an embedding vector!
    user_latent = Flatten()(MLP_Embedding_User(user_input))
    item_latent = Flatten()(MLP_Embedding_Item(item_input))
  
    # The 0-th layer is the concatenation of embedding layers
    vector = merge([user_latent, item_latent], mode = 'concat')
  
    # MLP layers
    for idx in xrange(1, num_layer):
        layer = Dense(layers[idx], W_regularizer= l2(reg_layers[idx]), activation='relu', name = 'layer%d' %idx)
        vector = layer(vector)
  
    # Final prediction layer
    prediction = Dense(1, activation='sigmoid', init='lecun_uniform', name = 'prediction')(vector)
  
    model = Model(input=[user_input, item_input], 
                  output=prediction)
  
    return model

NeuMF.py

$\phi^{GMF} = \textbf{p}{u}^{G} ⊙ \textbf{q}{i}^{G}$

$\phi^{MLP} = a_{L}(\textbf{W}{L}^{T}(a{L-1}(...a_{2}(\textbf{W}{2}^{T} {\textbf{p}{u}^{M} \choose \textbf{q}{i}^{M}} + \textbf{b}{2})...)) +\textbf{b}_L)$

$\hat{y}_{ui} = \sigma(\textbf{h}^{T} {\phi^{GMF} \choose \phi^{MLP}})$

• GMF와 MLP의 유저와 아이템 임베딩을 공유하는 것은 fused model의 성능을 저하할 수 있음

• 따로 임베딩 학습하고 마지막 히든 레이어에서 concat한다.

• MLP의 활성화 함수는 ReLU를 사용

• 선형성을 가지는 GMF와(sigmoid) 비선형성을 가지는 MLP(ReLU)를 합하여 user와 item의 latent 구조를 모델링한다.

• INPUT

  • user id, item id

• OUTPUT

  • predicted implicit rating

• GMF

  • embedding dim = 8

  • user embedding * item embedding , element wise product 를 한다.

• MLP

  • embedding dim = 8

  • concat(user embedding, item embedding)

  • dense(64) -> dense(32) -> dense(16) -> dense(8)

  • ReLU

    

    # 모델 구성 함수
    def get_model(num_users, num_items, mf_dim=10, layers=[10], reg_layers=[0], reg_mf=0):
    assert len(layers) == len(reg_layers)
    num_layer = len(layers) #Number of layers in the MLP
    # Input variables
    user_input = Input(shape=(1,), dtype='int32', name = 'user_input')
    item_input = Input(shape=(1,), dtype='int32', name = 'item_input')
    
    # GMF Embedding layer
    # 유저 임베딩 input dim = 유저의 nunique, output dim = 8 
    MF_Embedding_User = Embedding(input_dim = num_users, output_dim = mf_dim, name = 'mf_embedding_user',
                                init = init_normal, W_regularizer = l2(reg_mf), input_length=1)
    # 아이템 임베딩 input dim = 아이템의 nunique, output dim = 8
    MF_Embedding_Item = Embedding(input_dim = num_items, output_dim = mf_dim, name = 'mf_embedding_item',
                                init = init_normal, W_regularizer = l2(reg_mf), input_length=1)   
    # MLP Embedding layer
    # 유저 임베딩 input dim = 유저의 nunique, output dim = 8 
    MLP_Embedding_User = Embedding(input_dim = num_users, output_dim = layers[0]/2, name = "mlp_embedding_user",
                                init = init_normal, W_regularizer = l2(reg_layers[0]), input_length=1)
    # 아이템 임베딩 input dim = 아이템의 nunique, output dim = 8
    MLP_Embedding_Item = Embedding(input_dim = num_items, output_dim = layers[0]/2, name = 'mlp_embedding_item',
                                init = init_normal, W_regularizer = l2(reg_layers[0]), input_length=1)   
    
    # GMF part
    mf_user_latent = Flatten()(MF_Embedding_User(user_input)) # 유저 임베딩 flattem 크기가 8인 임베딩 형성
    mf_item_latent = Flatten()(MF_Embedding_Item(item_input)) # 아이템 임베딩 flatten
    mf_vector = merge([mf_user_latent, mf_item_latent], mode = 'mul') # 유저임베딩과 아이템 임베딩 element-wise multiply 
    
    # MLP part 
    mlp_user_latent = Flatten()(MLP_Embedding_User(user_input)) # 유저 임베딩 flattem
    mlp_item_latent = Flatten()(MLP_Embedding_Item(item_input)) # 아이템 임베딩 flatten
    mlp_vector = merge([mlp_user_latent, mlp_item_latent], mode = 'concat') # 유저임베딩과 아이템 임베딩 concat
    for idx in xrange(1, num_layer): # layers [64,32,16,8]
      layer = Dense(layers[idx], W_regularizer= l2(reg_layers[idx]), activation='relu', name="layer%d" %idx)
      mlp_vector = layer(mlp_vector) # concat된 유저,아이템 임베딩이 64 -> 32 -> 16 -> 8 개의 노드를 가지는 FC 레이어를 통과한다.
    
    # Concatenate MF and MLP parts
    predict_vector = merge([mf_vector, mlp_vector], mode = 'concat') # GMF, MLP concat 
    
    # Final prediction layer
    # sigmoid 를 활성화 함수로 최종 prediction 생성
    prediction = Dense(1, activation='sigmoid', init='lecun_uniform', name = "prediction")(predict_vector) 
    
    model = Model(input=[user_input, item_input], 
                output=prediction)
    
    return model

Pre-training

• NeuMF의 loss function의 non-convecxity때문에 locally-optimal 하게 된다.

• GMF와 MLP의 weight를 랜덤초기화한다음 수렴할 때까지 학습하고, 각각의 학습된 weight를 NeuMF의 초기 파라미터로 사용.

• $\textbf{h} <- {\alpha \textbf{h}^{GMF} \choose (1-\alpha) \textbf{h}^{MLP}}$

• h는 마지막 output layer의 weight 의미

• $\alpha$ 는 hyperparameter임. 저자는 0.5를 사용

• GMF와 MLP 학습할 때는 더 빠른 수렴과 학습률 조정의 어려움을 피하기 위해 Adam을 사용하고

• NeuMF 학습할때는 pre-train된 가중치로 초기화하고 모멘텀을 저장하지 않기 때문에 vanilla SGD를 사용

# pre-trained model
def load_pretrain_model(model, gmf_model, mlp_model, num_layers):
    # MF embeddings
    gmf_user_embeddings = gmf_model.get_layer('user_embedding').get_weights()
    gmf_item_embeddings = gmf_model.get_layer('item_embedding').get_weights()
    model.get_layer('mf_embedding_user').set_weights(gmf_user_embeddings)
    model.get_layer('mf_embedding_item').set_weights(gmf_item_embeddings)

    # MLP embeddings
    mlp_user_embeddings = mlp_model.get_layer('user_embedding').get_weights()
    mlp_item_embeddings = mlp_model.get_layer('item_embedding').get_weights()
    model.get_layer('mlp_embedding_user').set_weights(mlp_user_embeddings)
    model.get_layer('mlp_embedding_item').set_weights(mlp_item_embeddings)

    # MLP layers
    for i in xrange(1, num_layers):
        mlp_layer_weights = mlp_model.get_layer('layer%d' %i).get_weights()
        model.get_layer('layer%d' %i).set_weights(mlp_layer_weights)

    # Prediction weights
    gmf_prediction = gmf_model.get_layer('prediction').get_weights()
    mlp_prediction = mlp_model.get_layer('prediction').get_weights()
    new_weights = np.concatenate((gmf_prediction[0], mlp_prediction[0]), axis=0)
    new_b = gmf_prediction[1] + mlp_prediction[1]
    model.get_layer('prediction').set_weights([0.5*new_weights, 0.5*new_b])    
    return model

Negative sampling

positive sample 한개당 4개의 negative sample 추출해서 positive, negative 둘다 균형적으로 학습할 수 있도록 함

참고: https://developers.google.com/machine-learning/recommendation/dnn/training

# 네거티브 샘플링 함수
def get_train_instances(train, num_negatives):
    user_input, item_input, labels = [],[],[]
    num_users = train.shape[0]

    for (u, i) in train.keys():
        # positive instance 연관이 있는 샘플(시청한 샘플)
        user_input.append(u)
        item_input.append(i)
        labels.append(1) 
        # negative instances 연관이 없는 샘플(시청하지 않은 샘플) 4개를 뽑는다. 
        for t in xrange(num_negatives):
            j = np.random.randint(num_items)
            while train.has_key((u, j)):
                j = np.random.randint(num_items)
            user_input.append(u)
            item_input.append(j)
            labels.append(0)
    return user_input, item_input, labels # train sample 하나당 4개의 negative sample을 뽑는다.

Build model

# Build model
# 옵티마이저는 adam을 사용
model = get_model(num_users, num_items, mf_dim, layers, reg_layers, reg_mf)
if learner.lower() == "adagrad": 
    model.compile(optimizer=Adagrad(lr=learning_rate), loss='binary_crossentropy')
elif learner.lower() == "rmsprop":
    model.compile(optimizer=RMSprop(lr=learning_rate), loss='binary_crossentropy')
elif learner.lower() == "adam":
    model.compile(optimizer=Adam(lr=learning_rate), loss='binary_crossentropy')
else:
    model.compile(optimizer=SGD(lr=learning_rate), loss='binary_crossentropy') # 논문 저자는 adam 사용

Training model

# Training model 
# 정해진 에폭 만큼 모델 학습
for epoch in xrange(num_epochs):
    t1 = time()
    # 네거티브 샘플링을 통해 학습 데이터 생성 
    user_input, item_input, labels = get_train_instances(train, num_negatives) 

    # 모델 학습 
    hist = model.fit([np.array(user_input), np.array(item_input)], #input
                     np.array(labels), # labels 
                     batch_size=batch_size, nb_epoch=1, verbose=0, shuffle=True) 
    t2 = time()

    # Evaluation 
    if epoch %verbose == 0:
        (hits, ndcgs) = evaluate_model(model, testRatings, testNegatives, topK, evaluation_threads)
        hr, ndcg, loss = np.array(hits).mean(), np.array(ndcgs).mean(), hist.history['loss'][0]
        print('Iteration %d [%.1f s]: HR = %.4f, NDCG = %.4f, loss = %.4f [%.1f s]' 
              % (epoch,  t2-t1, hr, ndcg, loss, time()-t2))
        if hr > best_hr:
            best_hr, best_ndcg, best_iter = hr, ndcg, epoch
            if args.out > 0:
                model.save_weights(model_out_file, overwrite=True)

print("End. Best Iteration %d:  HR = %.4f, NDCG = %.4f. " %(best_iter, best_hr, best_ndcg))
if args.out > 0:
    print("The best NeuMF model is saved to %s" %(model_out_file))

Dataset.py

데이터셋 불러오는 클래스가 정의되어있음

ml-1m 데이터셋과 pinterest 데이터셋 두가지 중에 선택해서 불러올 수 있다.

class Dataset(object):
    '''
    classdocs
    '''

    def __init__(self, path):
        '''
        Constructor
        '''
        self.trainMatrix = self.load_rating_file_as_matrix(path + ".train.rating")
        self.testRatings = self.load_rating_file_as_list(path + ".test.rating")
        self.testNegatives = self.load_negative_file(path + ".test.negative")
        assert len(self.testRatings) == len(self.testNegatives)

        self.num_users, self.num_items = self.trainMatrix.shape

    def load_rating_file_as_list(self, filename):
        ratingList = []
        with open(filename, "r") as f:
            line = f.readline()
            while line != None and line != "":
                arr = line.split("\t")
                user, item = int(arr[0]), int(arr[1])
                ratingList.append([user, item])
                line = f.readline()
        return ratingList

    def load_negative_file(self, filename):
        negativeList = []
        with open(filename, "r") as f:
            line = f.readline()
            while line != None and line != "":
                arr = line.split("\t")
                negatives = []
                for x in arr[1: ]:
                    negatives.append(int(x))
                negativeList.append(negatives)
                line = f.readline()
        return negativeList

    def load_rating_file_as_matrix(self, filename):
        '''
        Read .rating file and Return dok matrix.
        The first line of .rating file is: num_users\t num_items
        '''
        # Get number of users and items
        num_users, num_items = 0, 0
        with open(filename, "r") as f:
            line = f.readline()
            while line != None and line != "":
                arr = line.split("\t")
                u, i = int(arr[0]), int(arr[1])
                num_users = max(num_users, u)
                num_items = max(num_items, i)
                line = f.readline()
        # Construct matrix
        mat = sp.dok_matrix((num_users+1, num_items+1), dtype=np.float32)
        with open(filename, "r") as f:
            line = f.readline()
            while line != None and line != "":
                arr = line.split("\t")
                user, item, rating = int(arr[0]), int(arr[1]), float(arr[2])
                if (rating > 0):
                    mat[user, item] = 1.0
                line = f.readline()    
        return mat

evaluate.py

평가함수 클래스가 구현되어있음

top-K recommendation에서 Hit_Ratio, NDCG 를 구하는 함수, k=10

def evaluate_model(model, testRatings, testNegatives, K, num_thread):

    hits, ndcgs = [],[]
    if(num_thread > 1): # Multi-thread
        pool = multiprocessing.Pool(processes=num_thread)
        res = pool.map(eval_one_rating, range(len(_testRatings)))
        pool.close()
        pool.join()
        hits = [r[0] for r in res]
        ndcgs = [r[1] for r in res]
        return (hits, ndcgs)
    # Single thread
    for idx in xrange(len(_testRatings)):
        (hr,ndcg) = eval_one_rating(idx)
        hits.append(hr)
        ndcgs.append(ndcg)      
    return (hits, ndcgs)

def eval_one_rating(idx):
    rating = _testRatings[idx]
    items = _testNegatives[idx]
    u = rating[0]
    gtItem = rating[1]
    items.append(gtItem)
    # Get prediction scores
    map_item_score = {}
    users = np.full(len(items), u, dtype = 'int32')
    predictions = _model.predict([users, np.array(items)], 
                                 batch_size=100, verbose=0)
    for i in xrange(len(items)):
        item = items[i]
        map_item_score[item] = predictions[i]
    items.pop()

    # Evaluate top rank list
    ranklist = heapq.nlargest(_K, map_item_score, key=map_item_score.get)
    hr = getHitRatio(ranklist, gtItem)
    ndcg = getNDCG(ranklist, gtItem)
    return (hr, ndcg)

def getHitRatio(ranklist, gtItem):
    for item in ranklist:
        if item == gtItem:
            return 1
    return 0

def getNDCG(ranklist, gtItem):
    for i in xrange(len(ranklist)):
        item = ranklist[i]
        if item == gtItem:
            return math.log(2) / math.log(i+2)
    return 0

참고자료

https://leehyejin91.github.io/post-ncf/

https://dnddnjs.github.io/recomm/2019/08/15/neural_collaborative_filtering/

https://hwa-a-nui.tistory.com/23

이외 NCF관련 구현 코드 참고할만한 자료

https://github.com/LeeHyeJin91/Neural_CF

https://keras.io/examples/structured_data/collaborative_filtering_movielens/

📄 Neural Collaborative Filtering(2017, Xiangnan He)

ABSTRACT

• 논문이 발제된 2017년에는 딥러닝이 음성 인식, 컴퓨터 비전 그리고 자연어 처리와 같은 분야에서 다양한 성공적인 결과를 낳았지만, 추천 시스템에서의 딥러닝 기술은 상대적으로 적은 적용 사례를 보여왔습니다.

• 이번 논문에서는, implicit feedback에 기반한 collaborative filtering이라는 추천 알고리즘을 딥러닝을 적용하여 다뤄보도록 하였습니다.

• 추천 시스템에 딥러닝을 활용한 최근(2017년) 연구들을 보게 되면, 대부분 아이템의 설명 텍스트, 노래의 음향 정보와 같은 부가 정보(auxiliary information)를 활용하는 경우가 많았습니다.

• collaborative filtering의 key factor을 모델링하기 위해서는 유저와 아이템 간의 interaction이 요구되며, 여전히 matrix factorization 기법에 의존하고 유저와 아이템의 latent features의 내적 과정을 거치게 됩니다.

• 내적 과정을 비선형적 관계를 학습할 수 있는 인공신경망 구조로 대체한다면, Neural Network-based Collaborative Filtering, NCF 라는 모델을 제시할 수 있습니다.

  • 비선형적인 특징을 모델에서 학습하기 위해, 유저와 아이템 간의 interaction을 학습할 수 있는 MLP를 적용할 수 있습니다.

  • 이번 논문에서 제안한 NCF 모델은 실제 데이터 셋에서 다른 최신 모델들과 비교해서 보다 좋은 성능을 보이기도 했습니다.

• 딥러닝을 활용한 추천 시스템이 보다 우수한 추천 성능을 보이는 것은 이번 프로젝트를 통해 깨달을 수 있었습니다.

1. INTRODUCTION

• 정보 폭발 시대에서, 추천 시스템은 e-커머스, 온라인 뉴스, sns 등과 같은 온라인 서비스에서 정보 과다를 완화하는 중요한 역할을 하고 있습니다.

• 개인화된 추천 시스템의 방법은 아이템에 대한 유저의 선호도와 과거 interaction 정보를 활용하는 collaborative filtering가 있습니다.

  • 다양한 collaborative filtering 방법 중에서, Matrix Factorization(MF)은 가장 대중적인 알고리즘이며, 유저와 아이템의 latent features(잠재 요인)을 벡터화함으로써, 유저와 아이템을 한 공간으로 투영하게 됩니다.

• Netfix prize가 유명해지면서, MF는 잠재 요인 추천 알고리즘의 de facto(기본적인) 알고리즘이 되었습니다.

• 많은 연구들이 MF 알고리즘을 개선하기 위해서, neighbor-based models을 적용해보거나, 아이템 데이터의 토픽 모델링을 결합하거나, 여러 feature를 포괄적으로 사용하기 위해 factorization machine 모델로 확장하기도 했습니다.

  • collaborative filtering에서 MF가 효과적임에도 불구하고, 내적을 통한 interaction을 학습하는 것은 성능 향상을 방해하는 것으로 잘 알려져 있습니다.

  • 예를 들어, explicit feedback을 통한 평점 예측 과제에서, 유저와 아이템의 bias 항을 추가함으로써 성능을 향상할 수 있다는 결과가 있습니다.

  • 즉, 항을 추가하는 것과 같은 시도는 내적 과정에 있어 아주 사소한 변경 혹은 시도에 불과하지만, 유저와 아이템 간의 latent feature interaction을 학습하는 것에 있어서는 매우 긍정적인 효과와 결과를 이끌어 낼 수 있었습니다.

• latent features을 선형적으로 곱하여 결합하는 내적 과정은 유저 interaction 데이터에서 복잡한 관계를 학습함에 있어 충분치 못한다고 해석할 수 있습니다.

• 이 논문에서는 handcraft가 주로 이뤄졌던 많은 이전 연구와는 달리, 딥러닝을 활용함으로써 데이터로부터 interaction을 학습하는 과정에 대해 연구하고 있습니다.

• 인공신경망은 continuous function(연속 함수)를 근사함이 가능하다는 것이 꾸준히 밝혀지고 있으며, 최근에는 딥러닝이 보다 다양한 분야에서 활용될 수 있음이 증명되고 있습니다.

• 그럼에도 불구하고, MF의 방대한 연구자료와 대조적으로 추천 시스템에 딥러닝이 활용된 연구 사례가 상대적으로 굉장히 적었습니다.

  • 딥러닝이 적용된 추천 시스템의 최근 연구 사례를 살펴보면, 대부분 부가 정보를 모델링하는 것 정도에 딥러닝을 활용했다는 사실을 확인할 수 있습니다.

• 이번 논문에서는 collaborative filtering의 관점에서 인공신경망 접근법을 구체화함으로써 앞선 연구 자료들의 문제점을 제시합니다.

• 이 과정에서는, 비디오를 보거나, 물품을 구매하거나, 아이템을 클릭하는 행동에 대한 유저의 선호도를 간접적으로 반영한 implicit feedback에 보다 초점을 맞추었습니다.

• 리뷰나 평점과 같은 explicit feedback과 비교했을 때, implicit feedback은 자동적으로 혹은 더 쉽게 추적하고 수집할 수 있습니다.

  • 그러나, 사용자 만족도에 대한 정확한 측정치가 아니고 부정적인 평가에 대한 자연스러운 반응이 부족하기 때문에 implicit feedback 사실 활용하기 어렵기도 합니다.

• 이번 논문에서는, 딥러닝을 활용하여 noisy implicit feedback을 모델링하는 것을 주로 다뤄보도록 하겠습니다.

• 논문의 주요 내용은 다음과 같습니다.

  • 유저와 아이템의 latent feature를 모델링하는 인공신경망 구조를 제시하고 구체화하여, 인공신경망 기반 collaborative filtering 모델인 NCF를 설계하였습니다.

  • MF 알고리즘을 기본적으로 따르는 NCF는 MLP를 통해 고차원의 비선형적인 특징을 학습할 수 있습니다.

  • 2가지 현실 데이터에 NCF를 적용해봄으로써, 딥러닝을 활용한 collaborative filtering의 성능 향상과 효과성에 대해 보여줍니다.

2. PRELIMINARIES

• 먼저 implicit feedback을 CF에서 사용하기 위해서는 현재의 문제점과 방법론에 대해서 다뤄보아야 하고, MF 모델에서 대중적으로 사용되고 있는 내적 과정의 한계점에 대해서도 다뤄보아야 합니다.

2.1 Learning from Implicit Data

$$ y_{u,i} = \begin{cases}1, \ \text{if interaction(user $u$, item $i$) is observed} \cr 0, \ \text{otherwise} \cr\end{cases} $$

• 유저와 아이템의 수를 M과 N으로 하는 R 행렬을 정의할 때, feedback의 발생 여부를 기준으로 1 / 0 으로 행렬을 정의할 수 있습니다.

  • 이 때, implicit feedback이란 유저와 아이템의 interaction을 의미할 수는 있으나, 발생 여부를 유저가 아이템을 선호한다고 정의할 수는 없습니다.

  • 반대로, interaction이 발생하지 않았다고 하더라도, 유저가 아이템을 싫어한다고 생각하기 보다는 인지하지 못하는 경우에도 interaction이 발생하지 않기 때문에 0이 부여될 수 있습니다.

  • 이러한 경우가 유저의 선호도에 대한 noise 신호를 의미하는 implicit data로부터 발생하는 학습의 어려움이라고 할 수 있습니다.

  • 또한, 유저와 아이템 간의 interaction이 발생하지 않는 경우에는, 이를 missing data로 처리해야 하며 부정적인 feedback에 대한 interaction을 파악하기 어렵습니다.

• implicit feedback의 추천 과정에서 발생하는 문제로는, 아이템을 랭킹화하기 위한 unobserved enteries(=interaction이 존재하지 않는 아이템 set)의 score를 예측하는 다음 과정에서 발생합니다.

$$ \hat{y}_{u,i} = f(u,i|\Theta),\ \ where \ f \ \ \text{is interaction function}, \Theta \ \text{is model parameters} \ $$

• 위 수식에 대해 조금 설명하자면, $f$는 유저와 아이템이 입력으로 주어졌을 때, score를 return하는 interaction function이며, $\Theta$ 는 해당 function의 parameter라고 생각하면 될 것 같습니다.

• 이 때, 해당 function의 parameter를 최적화할 수 있는 목적 함수, objective function은 두 가지가 있습니다.

  • $L_{1} = min \dfrac {1}{2}(\hat{y}{u, i} - y{u, i})^2 : \text{pointwise loss}$
  • $L_{2} = max(0, f(y_{unobs})-f(y_{obs})+\alpha) \ \ s.t \ \ rank(y_{obs}) >rank(y_{unobs}) : \text{pairwise loss}$

• pointwise loss의 경우에는 실제값과 예측값의 차이를 최소화(minimize) 하는 목적 함수로 보통 회귀 문제에서 사용되곤 합니다.

  • negative feedback 데이터의 부족을 처리하기 위해서, interaction이 발생하지 않은 데이터를 하여금 negative feedback으로 처리하거나 sampling 하여 처리하는 방법을 적용하기도 했습니다.

• pairwise loss의 경우에는 관측된 데이터(interaction이 발생한)가 그렇지 않은 데이터에 비해 링킹이 높아야 한다는 아이디어에 기반하여, 관측된 데이터와 관측되지 않은 데이터의 랭킹 차를 최대화(maximize)하는 목적 함수입니다.

• 다시 돌아가서, 논문에서 제시하는 NCF 모델 구조는 인공신경망을 사용함으로써 위 두 목적 함수를 모두 만족하는 결과를 얻을 수 있다고 합니다.

2.2 Matrix Factorization

• MF, Matrix Factorization은 유저, $u$와 아이템, $i$의 latent features인 $p_u, q_i$의 반복적인 내적을 통해 interaction인 $y_{u,i}$를 추정하게 됩니다.

  • $K$는 각 latent feature의 차원을 의미하며, 유저와 아이템의 독립적인 latent factor를 동일한 weight를 기반으로 선형적으로(linearly) 결합하게 됩니다.

$$ \hat{y}{u,i}= f(u,i|\mathbf{p}{u}, \mathbf{q}{i}) = \mathbf{p}{u} \mathbf{q}{i}^{T}= \sum{k=1}^K p_{uk} q_{ki} $$

• 계속해서 MF의 내적 과정은 유저와 아이템의 복잡한 관계를 표현함에 있어 한계점을 가진다고 말하는데, 다음 그림이 이를 설명합니다.

• 위와 같이 유저-아이템 행렬이 존재하게 된다면, 두 유저간 유사도는 내적 혹은 코사인 유사도, 자카드 유사도를 통해 구해볼 수 있습니다.

• 여기서, 유저 $u$ 와 $j$의 유사도를 $s_{ij}$로 표현할 때, 유사도 순으로 정렬하게 되면 유저 (2,3), 유저 (1,2), 유저 (1,3) 순으로 높은 유사도를 보이며 유사도 관계를 벡터 공간에서 표현하게 되면 우측 그림과 같습니다.

$$ s_{23}(0.66) > s_{12}(0.5) > s_{13}(0.4) $$

• 그런데 이 때, 새로운 유저 4가 등장함으로써, 다른 유저들과의 유사도가 계산되어 다음과 같은 유사도 관계가 형성되게 되면 MF 모델에서 공유하고 있던 벡터 공간에서 유저 4를 표현하는 것에 있어 한계를 가지게 되고, 결과적으로 ranking loss가 커지는 현상이 발생하게 됩니다.

$$ s_{41}(0.6) > s_{43}(0.4) > s_{42}(0.2) $$

• 정리하자면, Matrix Factorization의 단순하고 고정된 내적 과정은 저차원 latent space에서 복잡한 유저와 아이템의 관계를 추정하는 것에 한계점을 가진다고 할 수 있습니다.

• 이러한 문제점을 해결하는 방법 중 하나는 매우 큰 K차원의 latent factor를 지정하는 것이지만, 이 방법 또한 모델의 generalization 관점에 있어 부정적인 결과를 낳을 수 있습니다.

3. NEURAL COLLABORATIVE FILTERING

3.1 General Framework

• 인공신경망을 CF에 적용하기 위해서, 위 그림과 같이 한 층의 결과가 다른 층의 입력으로 이루어져 interaction을 추정하는 MLP 구조를 적용해 볼 수 있습니다.

  • 입력층의 $v^U_u, v^I_i$ 두 벡터는 각각 유저와 아이템의 벡터를 의미하며, 다양한 방법으로 임베딩될 수 있습니다.

  • 이 구조에서는 기본적인 CF 환경을 구성하기 위해서 오직 유저와 아이템의 idx를 활용하여 input feature를 구성하였으며, 원핫 인코딩 형태로 입력될 수 있습니다.

• Embedding layer에서는 Fully-connected layer를 통해 입력층의 벡터를 기반으로 dense vector를 얻을 수 있습니다.

  • 이 때 얻은 dense vector를 흔히 말하는 유저와 아이템의 latent vector라고 할 수 있으며, latent vecotr를 neural collaborative filtering layers라고 할 수 있는 MLP 구조에 입력하게 되면서 score를 예측하는 과정을 가지게 됩니다.

  • Fully-connected layer를 통해 dense vector를 얻는 과정은 hidden layer의 weight(가중치)가 업데이트되는 결과물이라고 생각하면 될 것 같습니다.

• MLP 구조는 최종적으로 특정 유저 $u$ 와 특정 아이템 $i$ 의 score $\hat {y}_{ui}$ 를 실제값과의 차이를 최소화하는 pointwise loss를 적용하여 추정하게 됩니다.(해당 논문에서는 인공신경망 모델링에 집중하기 위해서 Bayesian Personalized Ranking이나 margin-based loss와 같은 pairwise loss에 대한 과정은 고려하지 않았다고 합니다.)

$$ \hat{y}{u,i}= f(P^{T}v{u}^{U}, Q^{T}v_{i}^{I}|P,Q,\Theta_{f}) = \phi_{out}(\phi_{X}(...\phi_{2}(\phi_{1}(P^{T}v_{u}^{U}, Q^{T}v_{i}^{I}))...)), \ \ \ 0 \leqq \hat{y}_{u,i} \leqq 1 \ $$

3.1.1 Learning NCF

• 오차를 활용하는 pointwise loss에서는 정 분포에 근거하여 관측치를 설명하기 때문에 interaction의 발생 여부 1 / 0 으로 이루어져 있는 implicit data에 적용하기 적합하지 않다고 합니다.

• 그렇기 때문에 implicit data의 binary한 특징을 고려하여 logistic 혹은 probit function인 probabilistic function을 사용하고 추정하고자 하는 $\hat{y}_{ui}$가 [0, 1]의 범위값을 가지도록 설정할 수 있습니다.

  • probabilistic function에 대해 아주 간단히 설명하자면, 하나의 클래스에 대한 확률 예측 모델에서 실제값 $y = (1,0, 0.0)$ 이고 모델의 예측이 $\hat {y} = (0.4, 0.6)$이라면 probabilistic function은 $\hat {y}$이 $y$에 가까워지도록 파라미터를 조정해나가는 것입니다.

• 결국 Objective Function을 다음과 같이 설정할 수 있는데, binary cross-entropy loss와 같다고 이해할 수 있습니다.

  • 실제값 $y_{u,i} = 1$ 일 때, $\hat{y}{u,i} = 0$ 이라면, $L_1 = log 0 = \infty$ 이 될 것이며, $\hat{y}{u,i} = 1$ 이라면, $L_1 = log 1 = 0$이 되기 때문에 목점 함수의 방향성에 대해 쉽게 이해할 수 있습니다.

$$ L =-\sum_{(u,i) \in \mathcal{Y}} y_{u,i}\ log \ \hat{y}{u,i} - (\sum{(u,j) \ in \mathcal{Y}^{-}} (1- y_{u,i}) \ log \ (1-\hat{y}_{u,j}) ) \

\

= -\sum_{(u,i) \in \mathcal{Y} \cup \mathcal{Y}^{-} } ( y_{u,i}\ log \ \hat{y}{u,i} + (1- y{u,i}) \ log \ (1-\hat{y}_{u,i})) $$

• 해당 목적 함수에서 존재하는 $\mathcal{Y}^{-}$은 interaction이 발생하지 않은 데이터라고 할 수 있는데, 이러한 데이터는 unobserved interaction 데이터에서 negative sampling을 통해 구축할 수 있었습니다.

3.2 Generalized Matrix Factorization (GMF)

• 해당 섹션에서는 제안할 NCF 모델 구조에서 이뤄지는 Matrix Factorization에 대해 다루게 됩니다.

• GMF는 본래의 Matrix Factorization과 크게 다른 점은 없지만 내적인 아닌 element-wise product가 이뤄지고, edge weights와 activation function을 사용했다는 점에서 약간의 차이를 찾아볼 수 있었습니다.

$$ \hat{y}{ui} = a{out}(h^T(p_u{\odot}q_i)) \ where \ \ a_{out} : \text {sigmoid function}, \sigma(x),\ \ h^T : \text{edge weights} $$

• 이렇게 기존 MF와 약간의 다른 구조를 보이는 GMF가 가지는 장점으로는 다음과 같습니다.

  • $h$ 가중치에 non-uniform 특징으로 학습하게 되면 allows varing importance of latent dimension 할 수 있다고 합니다.

  • 그리고 $a_{out}$에 non-linear function을 적용하게 되면 linear한 MF 모델 보다 풍분한 표현력을 가질 수 있습니다.

3.3 Multi-Layer Perceptron (MLP)

• NCF 모델에서는 유저와 아이템이라는 2가지 벡터를 입력으로 받기 때문에 두 벡터를 연결(concat)하는 것으로 MLP에 대한 입력 벡터를 구성할 수 있습니다.

• 또한 유저와 아이템 간의 복잡한 interaction 관계를 학습하기 위해서 hidden layer를 여러 개 추가함으로써 flexibility하고 non-linearity한 딥러닝의 장점을 모델에 적용할 수 있습니다.

• concat된 입력 벡터가 layer를 통과하면, 선형 계산과 비선형 계산의 반복이 이뤄지게 되고 output layer에서 sigmoid function을 적용함으로써 특정 유저와 특정 아이템 간의 interaction 발생 여부에 대한 확률값을 추정할 수 있게 됩니다.

$$ z_{1} = \phi_{1}(P^{T}v_{u}^{U}, Q^{T}v_{i}^{I}) = \begin{bmatrix} P^{T}v_{u}^{U} \ Q^{T}v_{i}^{I} \end{bmatrix} \ z_{2} = \phi_{2}(z_{1}) = a_{2}(W_{2}^{T}z_{1} + b_{2}) \\cdots \ z_{L} = \phi_{L}(z_{L-1}) = a_{L}(W_{L}^{T}z_{L-1} + b_{L}) \ \hat{y}{u,i} = \sigma(h^{T}\phi{L}(z_{L-1})) $$

3.4 Fusion of GMF and MLP

• 지금까지 알아본 latent feature interaction에 대한 선형 계산의 GMF와 비선형 계산의 MLP를 NCF 모델 구조에서 함께 사용하게 된다면 각 알고리즘의 장점으로 유저와 아이템 간의 복잡한 관계를 학습함에 있어 보다 시너지 효과를 낼 것이라고 말합니다.

• 가장 단순한 방법으로는 GMF와 MLP 모두 같은 embedding layer를 공유하는 것이며, 각 모델의 결과값을 결합하여 확률값을 추정하는 것입니다.(같은 embedding layer를 공유한다는 것은 같은 embedding vector를 사용한다는 것으로 이해하면 될 것 같습니다.)

  • 하지만 이렇게 embedding layer를 공유하게 되면, 임베딩 차원이 같아야 함을 의미하기 때문에 각 모델에 적합한 임베딩 차원을 택할 수 없기 때문에 최적의 앙상블 결과를 얻을 수 없을 수도 있습니다.

• 하이브리드(fused) 모델에 유연성을 부여하기 위해서, GMF와 MLP에 다른 embedding layer를 사용함으로써 다른 embbedding vector를 사용하고 각 모델의 결과값을 연결(concat)하여 확률값을 추정할 수 있습니다.

  • 수식을 보면 각 모델에 유저 latent vactor가 $p^G_u, p^M_u$로 다르게 입력되었음을 알 수 있습니다.

$$ \phi^{GMF} = p_{u}^{G} \odot q_{i}^{G} \ \phi^{MLP} = a_{L}(W_{L}^{T}(a_{L-1}(...a_{2}(W_{2}^{T} \begin{bmatrix} p_{u}^{M} \ q_{i}^{M} \end{bmatrix}+b_{2})...)) + b_{L}) \ \hat{y}_{u,i} = \sigma(h^{T} \begin{bmatrix} \phi^{GMF} \ \phi^{MLP} \end{bmatrix}) $$

• 결론적으로 GMF와 MLP가 결합된 위 모델은 MF의 선형성과 DNN의 비선형성을 결합 및 활용하여 유저와 아이템의 관계를 모델링한 구조이며 논문에서는 해당 모델을 NeuMF, Neural Matrix Factorization 이라고 정의하였습니다.

4. EXPERIMENTS

• 이번 섹션에서는 설계한 NeuMF의 모델 성능을 측정하기 위한 실험에 대해 다뤄보고 있으며, 다음 3가지 질문을 기반으로 실험을 진행하였습니다.

RQ1 제시한 NCF 기법이 implicit CF 기법에서 높은 성능을 보이는가?

RQ2 제안한 최적 구조가 추천 과제에 있어 어떻게 작동하는가?

RQ3 DNN 구조가 유저 아이템의 interation을 학습함에 있어 효과적인가?

4.1 Experimental Settings

• MovieLens와 Pinterest, 2개의 데이터에서 실험을 진행하였으며 데이터에 대한 메타데이터는 다음과 같습니다.

4.2 Performance Comparison (RQ1)

• 성능 평가를 위한 HR@10과 NDCH@10에 대한 각 모델 별 성능 평가표입니다.

  • 상단 성능 평가표의 x축인 Factors는 마지막 hidden layer의 차원을 의미하며, 여기서는 model capability 그리고 predictive factors라고 합니다.

  • 하단 성능 평가표는 각 성능 지표의 Top-K를 의미하며, 이 때에도 NeuMF가 가장 좋은 성능을 보입니다.

4.3 Log Loss with Negative Sampling (RQ2)

• Iteration에 따른 각 history와 negative sampling ratio에 대한 성능 평가표입니다.

  • 상단 history 표를 통해 'The above findins provide empirical evidence for the rationality and effectiveness of optimizing the log loss for learning from implicit data'. 라고 하는데, 정확한 이유를 모르겠습니다. 아마, 학습이 진행됨에 따라 loss가 줄어들고 성능이 향상됨으로써 제안한 NeuMF가 implicit data에 적합하다는 것을 의미하는 것 같습니다.(그렇지 않다면 loss가 줄어들지도, 성능이 좋아지지도 않을 수 있기 때문입니다.)

  • pairwise objective function은 positive와 negative가 1대1의 쌍이 이뤄져야하는 반면에 pointwise loss을 통해 샘플링 비율을 조절할 수 있었고, negative sampling의 비율을 다르게 함으로써 성능을 비교할 수 있었습니다.

4.4 Is Deep Learning Helpful? (RQ3)

• 유저와 아이템의 관계를 학습함에 있어 DNN을 적용해본 간단한 연구였지만, 추천 과제에 있어 DNN 구조가 굉장히 적합할 수 있음을 알 수 있었다고 합니다.

• 해당 성능 평가표는 마지막 hidden layer의 capacity인 factor와 layer-depth에 따른 각 성능 지표를 보여주며, layer가 깊어질수록 높은 성능을 보이고 있음을 알 수 있습니다.

참고자료

• HyeJinLee, [논문 리뷰] Neural Collaborative Filtering
• Seho Kim blog, Neural Collaborative Filtering(NCF)
• HyeJinLee, Neural_CF-neural collaborative filtering tensorflow 2.0
• 웅사이다, Neural Collaborative Filtering 논문 리뷰
• Hello Blog!, [손실함수] Binary Cross Entropy
• Y.LAB, [Recommender System] - Python으로 Matrix Factorization 구현하기

1. 등장 배경

기존 모델의 문제점

• 추천시스템에서 기존에 많이 쓰이던 Matrix Factorization은 유저-아이템 상호작용을 내적의 형태로 표현
• latent facotrs 간의 곱셈을 선형으로 결합하는 내적은 유저-아이템 상호작용 데이터의 복잡한 구조를 알아내기 어렵게 함
• 새로운 유저가 나타나면 이를 저차원 공간에서 표현하기 어려움

  딥러닝 기반 추천시스템

• 비선형 변환 가능: 더 복잡한 유저-아이템 상호작용 파악 가능
• 더 나은 representation learning: hand-craft feature design 줄이고 다차원적 정보 처리 가능
• 시퀀스 모델링: RNN, CNN을 통하여 성능 향상
• 유연성: 딥러닝의 학습 환경 활용 가능

2. MLP-based Factorization

1) Neural Collaborative Filtering

기존 Matrix Factorization의 문제점

• 내적 등 선형 모델은 유저와 아이템 간의 복잡한 관계를 표현하는 데 한계가 있음
• 유저 2와 3이 제일 비슷하고, 유저 1과 3이 제일 덜 비슷함
• 새로운 유저 4를 기하학적으로 표현할 때, 유저 1과 제일 가깝게 하는 동시에 유저 2와 가장 멀게 하는 벡터를 찾을 수가 없음

Generalized Matrix Factorization (GMF)

Model Overview

1. Input Layer input으로 유저와 아이템의 one-hot vector 넣음 2. Embedding Layer input 단계의 sparse 벡터를 dense 벡터로 매핑 3. Element-wise Product k차원의 feature에 대응하는 값끼리 가중합하여 원하는 특징에 따라 가중치를 조정 가능하게 일반화 만약 이 가중치가 동일한 값, 1이 되면 기존의 Matrix Factorization과 같은 모습이 됨 4. Passing Fully Connected Layer 가중치를 학습하여 유저-아이템의 행렬 값 예측

GMF는 element-wise product하여 선형구조를 가지게 됨

Multilayer Perceptron (MLP)

Model Overview

MLP는 concatenate 되어 비선형의 활성화함수를 거치기 때문에 비선형구조를 가지게 됨

Neural Collaborative Filtering

GMF + MLP

의의

• 유저-아이템 상호작용을 표현하기 위해 Matrix Factorization의 선형성과 Multilayer Perceptron의 비선형성을 결합한 Neural Matrix Factorization
• 선형 공간에 기반한 기존 모델들이 갖는 한계를 Deep Neural Network를 도입하여 해결

2) Deep Neural Networks for YouTube Recommendation

기존 YouTube 추천시스템의 문제점

1. Scale: 엄청난 양의 데이터 & 제한된 컴퓨팅 파워
2. Freshness: 새로운 컨텐츠의 빠른 적용
3. Noise: 낮은 질의 메타 데이터, implicit feedback

   Model Overview

   

   ① Candidate Generation

Model Overview

Recommendation as Classification

• Extreme Multiclass Classification 문제로 정의
• user, context가 주어지면 특정 시간에 이 영상을 볼 확률을 구함 (v: context embedding, u: user embedding) => 유저 정보를 기반으로 한 user embedding을 하고, softmax에서 잘 분류되도록 학습

1. Embedding

• Video Embedding & Search Token Embedding
• 전체 모델의 Backpropagation을 통해 임베딩도 함께 학습

2. Combining

• 고정된 크기의 input으로 바꿈
• 여러 영상의 embedding vector의 average

3. Additional Features

• 다른 features 옆에 concatenate

4. Fully Connected ReLU Stack

5. Softmax Prediction

• 어떤 영상을 볼 것으로 예상되는지 영상별 가중치가 output으로 나옴
• Negative Sampling

6. Serving

• 요청이 왔을 때 상위 N개의 영상 추천
• Dot-product space에서 Nearest Neighbor Index를 뽑아서 가장 가까운 아이템 찾음

More Features

Example Age

• 히스토리 데이터를 기반으로 학습하면 오래된 아이템이 더 많이 추천됨
• freshness의 중요성

  그 외 features

• 모든 영상 시청 이력을 확인해야 편향이 생기지 않음
• 학습에 사용할 유저별 영상의 수 고정
• 새로운 검색 쿼리에 즉시 추천 엔진을 반영하지 않음
• 비대칭적 감상 패턴을 적용하여 학습

  ② Ranking Network

  
• Embedding*
• Feature Engineering*
• feature 분류
  • impression vs. query
  • univalent vs. multivalent
• feature가 매우 많아서 미리 가공
• 딥러닝이지만 엔지니어가 직접 가공

Embedding Categorical Features

• unique ID space ("vocabulary") 따로 임베딩
• 이 중에 impression 기준으로 Top N 영상 및 검색 이력 임베딩
• vocabulary에 없으면 zero embedding

Normalizing Continuous Features

• 값 x를 [0, 1)에 들어오도록 스케일링
• 𝑥 ̃, 𝑥 ̃^2, √(𝑥 ̃ )도 네트워크에 넣음

Modeling Expected Watch Time

• 추천한 영상의 감상 시간 예측
• 감상 시간은 안 봤으면 0, 봤으면 본 시간을 값으로 넣음
• Weighted Logistic Regression: 감상한 영상을 감상 시간으로 가중치 둠

의의

• 기존의 방법인 Matrix Factorization보다 성능 향상
• 딥러닝으로만 feature를 학습하기는 어렵기 때문에 hand-written feature 포함
• freshness, 사용자의 과거 행동 패턴을 잘 설명하는 feature 중요
• 감상 시간별로 가중치를 두어야 함

3. RNN-based Model

• 순차적 데이터 처리에 유용한 RNN
• 상호작용의 일시적 역학, 유저 행동의 순차적 패턴, 순차적 신호를 가진 side information 처리

  1) Session-based Recommendations with Recurrent Neural Networks

  기존 Session-based의 어려움

• 유저가 로그인하지 않은 환경에서는 latent vector 사용이 어려움
• session이나 cookie mechanism이 있지만 데이터가 매우 적음 => 유저의 순서 정보를 이용하여 추천시스템에 적용할 수 있는 방법을 RNN을 통해 제안
• 어떤 아이템을 경험했는가? + 가장 최근에 어떤 아이템을 클릭했는가?

Gated Recurrent Units (GRU)

1. Reset Gate: 과거의 정보 적당히 리셋
2. Update Gate: LSTM의 forget gate + input gate, 과거와 현재 정보의 최신화 비율 결정
3. Candidate: 현 시점의 정보 후보군 계산, 과거 은닉층의 정보를 그대로 이용하지 않고 리셋 게이트의 결과를 곱해서 이용
4. Hidden State 계산: update gate결과와 candidate 결과를 결합하여 현시점의 은닉층 계산

Model Overview

1. Input Layer input으로 Actual State of Session 넣음

• Actual Event의 아이템: 1-of-N encoding vector
• 세션 안의 이벤트: weighted sum vector (더 일찍 일어난 사건은 discounted)

2. Embedding Layer RNN 특성상 long term에 약하기 때문에 안정성을 위해 정규화

*3. GRU Layer * 아이템에 대한 선호도 예측하는 학습

*4. Output Layer * 해당 세션의 다음 이벤트 아이템 출력

Session-parallel Mini-batch

• 세션 병렬 방식의 Mini-batch로 input 넣음
• 다음 세션의 정보가 들어올 때 hidden state 초기화

Sampling the Output

• output을 샘플링해서 하위 집합만 연산
• Negative Sampling도 함께 시행
• 둘 다 popularity-based sampling 진행

Pairwise Ranking

• positive & negative 쌍으로 비교
• loss를 통해 positive item의 rank가 negative item의 rank보다 낮게 학습
• BPR & TOP1 사용

의의

• GRU라는 RNN을 추천시스템에 적용
• session-parallel mini-batch와 ranking loss function을 이용한 session-based 추천시스템

2) Neural Attentive Session-based Recommendation

기존 RNN-based Model의 문제점

• 최근의 순차적 정보만 고려하면 유저의 주요 목적을 놓치게 됨
• 유저의 순차적 행동 & 현재 세션에서의 주요 목적을 함께 고려

Model Overview

• 시점 t의 attention signal에 따라 고차원의 hidden representation으로 인코딩

Global Encoder

• RNN을 통과하고 마지막으로 나오는 hidden state가 global information

Local Encoder

Item-level Attention Mechanism

• 디코더가 입력 시퀀스의 다른 부분들을 다양하게 고르고 선형결합할 수 있도록 함

NARM

의의

• 현재 상태의 유저의 순차적 행동과 주요 목적을 함께 고려 (local information + global information)
• bi-linear scheme를 통해 연산량을 줄이고 성능 향상
• attention mechanism 적용
• 긴 세션에서 더 좋은 성능

3. AE-based Model

AutoEnocder기반의 추천시스템 모델을 설명하기에 앞서 간단하게 AutoEnocder의 개념에 대해 설명하고자 한다. AutoEnocder란 그림과 같이 Input과 output이 똑같은 형태의 모델을 말한다. AutoEnocder에서 Econder는 코드를 압축하는 역할을 하고 Decoder는 압축된 코드를 해석하는 역할을 한다.

AutoEnocder는 4가지 키워드로 설명할 수 있다. 바로 Unsupervised Learning, Manifold Learning, Generative Model Learning, Maximum Likelihood Density Estimation 이다. Unsupervised Learning인 이유는 AutoEnocder가 input을 받아 똑 같은 형태의 input을 복원하는 식으로 학습이 진행되는데 여기서 오직 데이터를 input Data만을 사용하기 때문이다. Manifold Learning인 이유는 Encoder가 Latent Space로 차원을 축소하는 역할을 수행하기 때문이다. Generative Model Learning인 이유는 Decoder가 input Data로 복원하는 역할을 수행하며 이것이 마치 데이터를 생성하는 것과 유사하기 때문이다. Maximum Likelihood Density Estimation인 이유는 DNN의 학습 방법이 MLE와 동일한데 AutoEnocder는 이러한 DNN의 일종이기 때문이다.

Encoder가 차원을 축소하는 역할을 하기 때문에 이 축소된 차원에서 Latent Space를 찾을 수 있다. 그리고 Decoder가 input Data로 복원을 해주는데 이러한 형식이 마치 추천시스템의 Latent Model 과 유사하다. 이러한 특징 때문에 AutoEncoder를 추천시스템이 활용할 수 있다.

AutoEnocder의 차원 축소와 복구 과정을 이용하여 컨텐츠 추천이 가능하다. 예를 들어서 input으로 사용자의 컨텐츠 Matrix가 들어왔다고 가정한다면 AutoEnocder의 Encoder와 Decoder를 거쳐서 복원된 사용자의 컨텐츠 Metrix를 활용하여 컨텐츠를 추천해줄 수 있다. AutoEnocder의 경우 비선형 활성화 함수를 활용하여 사용자 간의 관계를 모델링하기 때문에 성능이 좋다. 그리고 단순한 Matrix Factorization에 비하여 Sparse matrix(0이 많이 포함된)에서 좋은 성능을 보인다. 또한 평점 추천, 순위 추천, 클릭 여부, 시청 여부 등 모든 곳에 활용이 가능하다.

그렇다면 AutoEnocder의 발전된 형태인 VAE, DAE 등의 모델들도 추천시스템에 활용할 수 있을 까?

물론 AutoEnocder의 발전된 형태인 VAE, DAE 등의 모델들을 사용할 수 있으며 그 성능 또한 기본 AutoEnocder보다 우수하다고 한다.

Denoising AutoEncoder는 noise가 추가된 input data를 noise가 없는 input data로 복원시키는 방식의 모델이다. Denoising AutoEncoder 또한 복원된 matrix를 활용하여 추천시스템으로 사용 가능하다. 일부 데이터에 noise가 들어가기 때문에 조금 더 강건한 형태의 모델을 얻을 수 있다. 그리고 실제로 기본 AE보다 더 우수한 성능을 보인다고 한다.

Variational AutoEncoder는 축소된 차원으로 Z를 샘플링하여 Z를 정규 분포에 가깝게 만드는 방식의 모델이다. Variational AutoEncoder 또한 복원된 matrix를 활용하여 추천시스템으로 사용 가능하다. Latent Space가 정규 분포에 가깝기 때문에 다루기 쉬워지고 컨트롤할 수 있으며, Sparse한 부분이 줄어들어 조금 더 유용한 Space를 얻을 수 있다. 그리고 실제로 기본 AE보다 더 우수한 성능을 보인다고 한다.

AutoEncoder는 축소된 차원인 Latent Space를 활용하여 추천이 가능하다. 전처리 된 컨테츠 matrix를 축소하여 축소된 차원에서 Cosine similarity로 거리를 측정하여 컨텐츠 간의 유사도를 구해서 이 유사도를 기준으로 추천을 할 수 있다.

AutoEncoder는 Matrix completion을 활용하여 추천이 가능하다. 사용자의 컨텐츠 시청 정보를 복원 시켜서 복원된 Matrix를 바탕으로 사용자 마다 컨텐츠 시청 확률을 출력하여 높은 순서대로 컨텐츠 추천이 가능하다.

이 밖에도 사용자의 평점, 영화의 다양한 feature 등 다양한 방식으로 활용을 할 수 있다.

추천 시스템 모델들은 각 모델마다 장단점이 존재하기 때문에 1개만 활용해서는 안된다. 예를 들어서 cold start 문제가 발생한다면 컨텐츠 기반의 모델이 더 우수할 것이고 어떠한 상황에서는 협업 필터링 기반의 모델이 더 우수할 수도 있다. 또한 여러 모델을 앙상블 하여서 추천 시스템 모델을 만들 수도 있다, 이렇듯 추천 시스템 모델들은 주어진 상황에 맞추어 여러 모델을 구성하여 활용해야 할 것이다.

알고리즘 및 모델 구현코드

https://github.com/SeongBeomLEE/Tobigs_Recommendation_System_Seminar/blob/main/Week2_Recommendation_Seminar_Code.ipynb

참고자료

https://developers.google.com/machine-learning/recommendation?hl=ko https://tkdguq05.github.io/2021/03/07/apriori-FP/ https://dnddnjs.github.io/recomm/2019/08/15/recommendation_system_basics/ https://leehyejin91.github.io/post-ncf/ https://www.youtube.com/watch?v=1fhNX_JFaow https://www.youtube.com/watch?v=h6vePourB7E&list=LL&index=1 https://yjjo.tistory.com/18 Zhang, S., Yao, L., Sun, A., & Tay, Y. (2017). Deep Learning based Recommender System: A Survey and New Perspectives. ACM. He, X., Liao, L., Zhang, H., Nie, L., Hu, X., & Chua, T. (2017). Neural Collaborative Filtering. WWW. Cheng, H., Koc, L., Harmsen, J., Shaked, T., Chandra, T., Aradhye, H., … Shah, H. (2016). Wide & Deep Learning for Recommender Systems. Google Inc. Covington, P., Adams, J., & Sargin, E. (2016). Deep Neural Networks for YouTube Recommendations. RecSys. Hidasi, B., Karatzoglou, A., Baltrunas, L., Tikk, D. (2016). Session-based Recommendations with Recurrent Neural Networks. ICLR. Li, J., Ren, P., Chen, Z., Ren, Z., Lain, T., Ma, J. (2017). Neural Attentive Session-based Recommendation. ACM.