오늘은 추천 시스템에서 '시간'이라는 요소가 별점 예측에 어떤 영향을 미치는지, 그리고 이를 지난 "별점 예측(Rating Prediction) 모델"을 이해한 것에서, 어떻게 반영할 수 있을지 후딱 정리해 보려 합니다.

1. 별점에 미치는 ‘시간’의 영향

우리가 별점을 매길 때, 단순히 '취향'만 작용할까요? 사실 시간은 생각보다 큰 변수입니다.

• 명작의 법칙:
  • 오래된 영화일수록 평점이 높은 경향이 있습니다. 시간이 흘러도 회자되어 평점이 매겨지는 영화는 대개 '명작'인 경우가 많기 때문이죠.
• 주기적 패턴:
  • 계절이나 요일도 영향을 미칩니다.
  • 혹은, 명절 시즌이 되면 어김없이 영화에 대한 수요나 평가가 증가하기도 합니다.
• 선호도의 변화:
  • 서비스의 UI/UX 변화 (별점 부여 방식의 변경)
  • 커뮤니티 내의 재평가 여론 형성
  • 특정 시리즈 정주행으로 인한 팬심 상승
  • 시간이 흐르며 유저가 해당 장르의 전문가가 됨

그렇다면 시간 정보가 추천 예측에 필요하다는 건 알겠고,,,

그럼, 어떻게 시간 정보를 반영할 수 있을까요?

"파라미터를 시간의 함수로 표현하는 것"입니다. 즉, $t$에 따라 파라미터 값이 유동적으로 변하게 만들면 됩니다! 지난 번에 기본적인 bias 모델과 이 bias 모델에 유저와 아이템의 관계 정보도 반영한 Latent 모델을 정리했는데, 관련된 내용을 아래 글 참고!!

👉 Bias Model, Latent Model 이해하기

https://velog.io/@ah_yo_ninde_yo/추천-시스템-별점-예측Rating-Prediction-모델-이해하기

2. Temporal Bias Model

복잡한 Latent 모델에 바로 적용하기 전, 가장 기본이 되는 Bias(편향) 모델에 시간 정보를 반영해보자!!

기본 Bias 모델이 아래와 같았다면,

$$\alpha + \beta_{u} + \beta_{i}$$

시간 정보를 파라미터로 넣어주면 아래와 같다.

$$b_{u,i}(t) = \alpha + \beta_{u}(t) + \beta_{i}(t)$$

• $\beta_{u}(t)$ (User Bias): 시간이 흐름에 따라 변하는 유저의 평가 경향성. (어떤 유저는 갈수록 평점이 짜질 수 있음)
• $\beta_{i}(t)$ (Item Bias): 시간에 따른 아이템의 인기도 변화. (개봉 직후 거품이 빠지는 현상 등)

이제 본격적으로 각각 User Bias와 Item Bias를 어떻게 구성할 수 있을지 알아보겠다.

먼저 비교적 간단한 Item Bias 부터!!

2.1 Item Bias 모델링

아이템의 편향은 크게 두 가지 방식으로 나뉩니다.

• Binning (데이터 등분) : $$\beta_{i,\text{Bin}(t)}$$

  • 전체 시간을 일정 구간(Bin)으로 나누어 각 구간마다 독립적인 bias를 할당한다.
  • 예시) 아이템 1,000개 × 30개 구간 = 30,000개 파라미터

• Periodicity (주기성) : $$\beta_{i, period(t)}$$

  • 요일이나 계절 같은 주기적 특성을 반영

$$\beta_{i}(t) = \beta_{i} + \beta_{i,\text{Bin}(t)} + \beta_{i, period(t)}$$

2.2 User Bias 모델링

유저의 시간적 편향을 반영하기 위해서는 아이템보다 고려해야 하는 게 좀 더 많다. 기본적으로 유저는 아이템보다 훨씬 '변덕'이 심하다. 취향이 갑자기 바뀌기도 하는 등.. 따라서, 이러한 편향을 잘 반영하기 위해서는 아이템에서 등분을 나눴던 것보다 훨씬 잘게 나눠야 할 것이다. (⇒ 파라미터 증가) 또한, 유저 수가 아이템보다 훨씬 많아 파라미터는 더더욱 증가할 것이다.

[방법 1] Drifting dynamics (함수 활용)

수식을 통해 시간에 따른 변화를 부드럽게 표현합니다.

$$\beta_{u}^{(1)}(t) = \beta_{u} + \alpha_{u} \cdot \text{dev}_{u}(t)$$

• $$\text{dev}_{u}(t)$$ : 기준 시점으로부터의 시간 차이를 계산하는 함수
  • $$\text{dev}{u}(t) = \text{sign}(t - t{u}) \cdot |t - t_{u}|^{x}$$
    • $x$ : koren(논문 작성자)는 $x$를 0.4로 설정했다. (실험 결과 토대로)
    • $0.4$의 의미: (그래프를 그려보면) 시간이 지남에 따라 증가하긴 증가하는데, 증가 정도가 감소한다. 만약, $x$가 2 였으면 시간이 지남에 따라 증가 정도가 매우 가파르게 올랐을 것이다.

• $\alpha_{u}$: 유저별 시간 변화 가중치. (양수면 갈수록 후해지고, 음수면 갈수록 짜짐)

• 장점: 유저당 파라미터가 하나($\alpha_{u}$)만 추가되어 효율적이다.
• 한계: 정해진 함수 형태(시그모이드와 유사한 형태 등)로만 표현 가능하며, 갑작스러운 변화를 감지하지 못한다.

[방법 2] Spline (Interpolation 기법)

Drifting dynamics의 부족한 표현력을 보정하기 위한 방법이다. 유저마다 Control Points를 두어 시간에 따른 선호도 곡선을 더 유연하게 반영할 수 있다.

• 핵심: 유저별 별점 개수($n_u$)에 따라 Control Point의 개수를 다르게 설정한다.

  • (Koren은 $n_u^{0.25}$를 권장)
  • e.g.) 어떤 유저가 16개의 평점을 남겼다면? → 해당 유저의 Control Point는 $16^{0.25} = 2$개가 된다.

• 장점: Drifting dynamics보다 훨씬 정교한 선호도 변화 묘사가 가능하다.

• 한계: 파라미터 수가 늘어나며, 특정 날의 기분 같은 '갑작스러운 변화'는 여전히 감지하기 어렵다.

Per-day User Bias (일별 편향)

기존 방법만으로는 특정 날에만 발생하는 편향을 반영하기엔 한계가 있었다. 따라서, 유저의 '그날의 기분'을 반영하기 위해 아예 날짜별로 파라미터를 둔다.

그런데, 이때 날마다의 기분을 파라미터로 표현하려 한다면, 아래와 같은 문제가 발생합니다.

• 문제: 10만 유저 × 6년 치 데이터를 다 만들면 파라미터가 2억 개? 😱

따라서 아래와 같은 방법을 통해 해결합니다.

• 해결: 실제 유저가 별점을 남긴 날(평균 40일)에 대해서만 파라미터를 생성하여 400만 개 수준으로 압축!

즉, Per-day User Bias는 테스트 시점에서 '값을 더해주는 용도'가 아니라, 학습 데이터에 포함된 노이즈를 효과적으로 격리한다.

2.3 아이템 편향의 확장: Scaling Factor $c_u(t)$

지금까지는 유저와 아이템의 편향을 각각 구해서 단순히 '더해'주었다. 하지만 우리가 latent 모델에서 아이템과 유저의 관계에 대한 정보를 반영해 준 것처럼, 실제 현실에서는 Item bias가 영향에 미치는 정도가 시간과 유저마다 다름.

Item bias에 per day bias 더해 줄 수 있다! 심지어 같은 사람이라도 '시기와 상황'에 따라 대중성에 영향을 받는 정도가 유동적으로 변할 수 있기 때문에, 이러한 현실적인 요소를 수식에 반영하기 위해 도입된 것이 바로 Scaling Factor, $c_u(t)$ 이다.

$$\alpha + \underbrace{\beta_u + \alpha_u \cdot \text{dev}u(t) + \beta{u,t}}{\text{User Bias}(t)} + \underbrace{(\beta_i + \beta{i,\text{Bin}(t)}) }_{\text{Item Bias}(t)}$$

✅ 최종 Temporal Bias Model 수식

위 내용들을 모두 대입해서 쓰면 다음과 아래와 같다.

$$\alpha + \underbrace{\beta_u + \alpha_u \cdot \text{dev}u(t) + \beta{u,t}}{\text{User Bias}(t)} + \underbrace{(\beta_i + \beta{i,\text{Bin}(t)}) }_{\text{Item Bias}(t)}$$

• $\alpha$ (Global Offset)
  • 데이터셋 전체의 평균 평점 (모든 예측의 베이스라인).
• $\beta_u$ (User Bias)
  • 유저 고유의 성향 (기본적으로 점수를 후하게 주는지, 짜게 주는지).
• $\alpha_u \cdot \text{dev}_u(t)$ (Gradual Deviation)
  • 시간이 흐름에 따라 서서히 변하는 유저의 취향 변화(Drift).
• $\beta_{u,t}$ (Single-day Dynamics)
  • 특정 날짜($t$)*에 유독 평점이 튀는 현상을 반영. (예: 기분이 매우 좋거나 나쁜 날의 변덕)
• $\beta_i$ (Item Bias)
  • 아이템이 가진 고유의 매력도나 기본 인기도.
• $\beta_{i,\text{Bin}(t)}$ (Gradual Item Bias Drift)
  • 시간이 지나면서 변하는 아이템의 인기나 가치 (예: 개봉 직후 효과 소멸 등).
    

3. Temporal Latent Factor Models

이번엔 Bias를 넘어 유저와 아이템의 관계를 나타내는 Latent Factor(잠재 요인)에도 시간을 반영해보자.

3.1 $\gamma_u$ Bias 모델링

$$\alpha + \beta_u(t) + \beta_i(t) + \gamma_i^T \gamma_u(t)$$

이 때, $\gamma_{u}$는 이렇게 표현할 수 있다.

$\gamma_{u} \rightarrow \gamma_{u,k}(t) = \gamma_{u,k} + \alpha_{u,k} \cdot \text{dev}u(t) + \gamma{u,k,t}$

• $k$ : rank 중에 한 개

• 왜 $\gamma_i$ (아이템 벡터)에는 시간 정보를 안 넣나요?

  • 아이템(영화)의 고유 속성은 잘 변하지 않기 때문이다.
  • 아이템의 인기도 변화는 $\beta_i(t)$ (Bias)에서 이미 처리하므로, 벡터까지 동적으로 만들 필요가 없을 것이다.

    ✅ 최종 Temporal Latent Factor Model 수식

식을 풀어서 쓰면 다음과 같은 거대한 형태가 된다.

$$\alpha + \underbrace{\beta_u + \alpha_u \cdot \text{dev}u(t) + \beta{u,t}}{\text{User Bias}(t)} + \underbrace{(\beta_i + \beta{i,\text{Bin}(t)}) \cdot c_u(t)}{\text{Item Bias}(t)} + \gamma_i^T \underbrace{\left( \gamma_u + \alpha_u^{vec} \cdot \text{dev}_u(t) + \gamma{u,t} \right)}_{\text{User Latent Factor}(t)}$$

4. 교훈 및 실무 한계점

1. *Lessons

• 무작정 딥러닝 모델을 깊게 쌓는 것보다, 데이터의 도메인 특성(시간)을 수식에 정교하게 반영하는 것이 성능 향상에 매우 효과적이다.

2. Limitations:
   • Cold Start: 신규 유저에게는 적용하기 어렵다.
   • Data Density: Per-day Bias는 같은 날 여러 별점이 쌓여야 잘 학습된다. (데이터가 희소하면 '기분 탓'인지 '영화 탓'인지 알 수 없음)
   • 도메인 특성: 영화처럼 단발성 소비가 아닌, 반복 구매가 잦은 이커머스에는 그대로 적용하기엔 한계가 있습니다.

추천시스템에서 별점을 예측하는 방법은 크게 두 가지로 나뉩니다.

1. 유사도 기반 (Memory-based CF): 원본 데이터를 매번 참조하여 유사도를 계산
2. 모델 기반 (Model-based CF): 데이터의 패턴을 수학적 파라미터로 학습 그럼 하나씩 살펴볼까용~~
   

1. 유사도 기반 Rating Prediction (Memory-based CF)

• 가장 직관적인 방법에 해당합니다!
• item 들 간의 유사도 혹은 user들 간의 유사도를 활용해 user가 item에 내릴 별점($$r$$)을 가중평균으로 예측합니다.
  • 유사도 지표로 피어슨 상관계수(Pearson Correlation)를 사용하고, 그 결과값을 가중평균의 가중치로 사용합니다.
  • 분자 ($\sum S \cdot R$) 단순히 별점을 더하는 게 아니라, '나와 얼마나 닮았나($s_{ij}$)'를 곱해서 더합니다. 유사도가 높을 수록, 별점이 차지하는 비중(가중치)이 커집니다.
  • 분모 ($\sum |S|$) 왜 유사도의 합으로 나누냐면, 결과값의 단위(Scale)를 '별점'으로 되돌리기 위해서! 유사도를 곱해서 커진 값을 다시 유사도들의 총합으로 나누어줌으로써, 최종 예측값이 원래의 별점 범위(e.g. 1~5점) 안에 들어오게 만드는 '정규화' 과정입니다.
    

$$r = \frac{\sum (\text{Similarity} \times \text{Rating})}{\sum |\text{Similarity}|}$$

• $s_{ij}$: Item/혹은 User 사이 간의 유사도 (중 높은 N개)
• $r_{xj}$: 사용자 $x$가 기존에 아이템 $j$에 내린 점수
• $N$: 사용자 $x$가 평가한 아이템 집합

💡 Tip 수식에서는 분모의 유사도($s_{ij}$)에 절댓값을 씌우라고 되어 있지만, 실제 구현(Programming) 시에는 0 미만의 값은 모두 0으로 치부하는 것이 정확도가 더 높다고 합니다.

유사도가 음수일 때 '0'으로 처리하는 이유?

1. 성향 반대(Negative Correlation)의 불확실성 피어슨 상관계수에서 음수는 '정반대 취향'을 의미합니다. 하지만 추천 시스템처럼 데이터가 희소(Sparse)한 환경에서는 단순히 몇 개의 아이템에 대한 평가가 달랐을 뿐인데도 매우 큰 음수 유사도가 도출될 수 있습니다. 이를 '확신'으로 받아들여 예측에 반영하면 오히려 정확도가 떨어집니다.
2. Top-K Selection의 신뢰도 확보 유사도 순으로 상위 $N$개를 정렬(Sorting)할 때, 신뢰도가 낮은 음수값들이 상위에 노출되는 것을 막아야 합니다. 0으로 처리함으로써 오직 '나와 조금이라도 닮은' 데이터들만 예측 계산에 참여하게 하여 노이즈를 제거하는 것입니다.

⇒ 결론: 음수 유사도는 정보로서의 가치보다 노이즈로서의 성격이 강하므로, 실무에서는 이를 0으로 밀어버리는(Thresholding) 것이 일반적입니다.

1.1 Item-Item Collaborative Filtering

• 아이템 간의 유사도를 계산하여 user $x$가 item $i$에 내릴 별점($$r_{xi}$$)을 가중평균으로 예측합니다.

$$r_{xi} = \frac{\sum_{j \in N} s_{ij} \times r_{xj}}{\sum_{j \in N} |s_{ij}|}$$

• $s_{ij}$: 아이템 $i$와 아이템 $j$ 사이의 유사도
• $r_{xj}$: 사용자 $x$가 기존에 아이템 $j$에 내린 점수
• $N$: 사용자 $x$가 평가한 아이템 집합

$S_{ij}$(유사도)를 구하는 공식: 피어슨 상관계수

$$s_{ij} = \frac{\sum_{u \in U} (r_{ui} - \bar{r}i)(r{uj} - \bar{r}j)}{\sqrt{\sum{u \in U} (r_{ui} - \bar{r}i)^2} \sqrt{\sum{u \in U} (r_{uj} - \bar{r}_j)^2}}$$

• $\bar{r}$ : 해당 아이템이 받은 모든 별점의 평균
• 분자 : 아이템 $i와 j$ 모두 평가한 공통 유저들의 편차 곱 합계
• 분모_왼쪽 루트 : 아이템 $i$를 평가한 모든 유저의 편차 제곱합
• 분모_오른쪽 루트: 아이템 $j$를 평가한 모든 유저의 편차 제곱합

🔵 예제 (Item-Item CF) - 아이템 $b$와 아이템들 간의 유사도 ($s_{bj}$)

출처: 국민대학교 박하명 교수님

• 

  1. 사전 계산

• $\bar{r}$ : 해당 아이템이 받은 모든 별점의 평균
  • $\bar{r}_a$: $(4+5+5+3+1)/5 =$ 3.6
  • $\bar{r}_b$: $(3+2+4+4+5)/5 =$ 3.6
  • $\bar{r}_c$: $(5+3+4+3+2+1+4+2)/8 =$ 3.0
  • $\bar{r}_d$: $(2+4+5+4+2)/5 =$ 3.4
  • $\bar{r}_e$: $(5+3+2+4+3+4)/6 =$ 3.5
  • $\bar{r}_f$: $(4+2+3+3+1)/5 =$ 2.6
• 각 아이템의 분모 항에 들어갈 편차 제곱합의 루트($\sqrt{\sum (r_{ui} - \bar{r}_i)^2}$)
  • 아이템 a ($\bar{r}_a = 3.6$) : $\sqrt{(4-3.6)^2 + (5-3.6)^2 + (5-3.6)^2 + (3-3.6)^2 + (1-3.6)^2} = \sqrt{11.2} \approx \mathbf{3.346}$
  • 아이템 b ($\bar{r}_b = 3.6$) : $\sqrt{(3-3.6)^2 + (2-3.6)^2 + (4-3.6)^2 + (4-3.6)^2 + (5-3.6)^2} = \sqrt{5.2}$ $\approx\mathbf{2.280}$
  • 아이템 c ($\bar{r}_c = 3.0$) : $\sqrt{(5-3)^2 + (3-3)^2 + (4-3)^2 + (3-3)^2 + (2-3)^2 + (1-3)^2 + (4-3)^2 + (2-3)^2} = \sqrt{12.0} \approx \mathbf{3.464}$
  • 아이템 d ($\bar{r}_d = 3.4$) : $\sqrt{(2-3.4)^2 + (4-3.4)^2 + (5-3.4)^2 + (4-3.4)^2 + (2-3.4)^2} = \sqrt{7.2} \approx \mathbf{2.683}$
  • 아이템 e ($\bar{r}_e = 3.5$) : $\sqrt{(5-3.5)^2 + (3-3.5)^2 + (2-3.5)^2 + (4-3.5)^2 + (3-3.5)^2 + (4-3.5)^2} = \sqrt{5.5} \approx \mathbf{2.345}$
  • 아이템 f ($\bar{r}_f = 2.6$) : $\sqrt{(4-2.6)^2 + (2-2.6)^2 + (3-2.6)^2 + (3-2.6)^2 + (1-2.6)^2} = \sqrt{5.2} \approx \mathbf{2.280}$

    2. 아이템 $b$와 $a \sim f$ 각각의 유사도 도출 과정

① $sim(b, a) = -0.11$

• 분자 계산 :
  • 공통 유저 : 유저 $J$
    • 유저 $J$: $(5 - 3.6) \times (3 - 3.6) = 1.4 \times (-0.6) = -0.84$
• 분모 계산:
  • 아이템 $b$를 본 5명의 편차 제곱합 : $\sqrt{5.2} \approx \mathbf{2.28}$
  • 아이템 $a$를 본 5명의 편차 제곱합 : $\sqrt{11.2} \approx \mathbf{3.35}$
• 최종 결과 ($S_{ba}$) $= -0.84 / (2.28 \times 3.35) = -0.84 / 7.638 \approx \mathbf{-0.11}$

② $sim(b, b) = 1$

• 자기 자신과의 비교이므로 모든 데이터가 완벽히 일치합니다. 따라서 상관계수는 항상 $1$이 됩니다.

③ $sim(b, c) = -0.10$

• 분자 계산 :
  • 공통 유저 : 유저 $C, F, I$
    • 유저 $C$: $(2-3.6) \times (3-3.0) = 0$
    • 유저 $F$: $(4-3.6) \times (3-3.0) = 0$
    • 유저 $I$: $(4-3.6) \times (1-3.0) = 0.4 \times -2.0 = -0.8$ $\rightarrow 0 + 0 + (-0.8) =-0.8$
• 분모 계산:
  • 아이템 $b$를 본 5명의 편차 제곱합 : $\sqrt{5.2} \approx \mathbf{2.28}$
  • 아이템 $c$를 본 8명의 편차 제곱합 : $\sqrt{12.0} \approx \mathbf{3.46}$
• 최종 결과 ($S_{bc}$) $= -0.8 / (2.28 \times 3.46) = -0.8 / 7.888799 \approx \mathbf{-0.10}$

④ $sim(b, d) = 0.14$

• 분자 계산 :
  • 공통 유저 : *유저 $J$ *
    • 유저 $J$: $(5 - 3.6) \times (4 - 3.4) = 1.4 \times 0.6 = \mathbf{0.84}$
• 분모 계산:
  • 아이템 $b$를 본 5명의 편차 제곱합 : $\sqrt{5.2} \approx \mathbf{2.28}$
  • 아이템 $d$를 본 5명의 편차 제곱합 : $\sqrt{7.2} \approx \mathbf{2.683}$
• 최종 결과 ($S_{bd}$) $= 0.84 / (2.28 \times 2.68) = 0.8 / 6.1104 \approx \mathbf{0.14}$

⑤ $sim(b, e) = -0.07$

• 분자 계산 :
  • 공통 유저 : *유저 $A, I, J$ *
    • 유저 $A$: $(3 - 3.6) \times (5 - 3.5) \approx -0.9$
    • 유저 $I$: $(4 - 3.6) \times (3 - 3.5) = -0.2$
    • 유저 $J$: $(5 - 3.6) \times (4 - 3.5) = 0.7$ $\rightarrow (-0.9) + (-0.2) + 0.7 = \mathbf{-0.4}$
• 분모 계산:
  • 아이템 $b$를 본 5명의 편차 제곱합 : $\sqrt{5.2} \approx \mathbf{2.28}$
  • 아이템 $e$를 본 6명의 편차 제곱합 : $\sqrt{5.5} \approx \mathbf{2.34}$
• 최종 결과 ($S_{be}$) $= -0.4 / (2.28 \times 2.34) \approx -0.4 / 5.335199 \approx \mathbf{-0.07}$

⑥ $sim(b, f) = 0.108$

• 분자 계산 :
  • 공통 유저 : *유저 $J$ *
    • 유저 $J$ : $(5 - 3.6) \times (3 - 2.6) = 1.4 \times 0.4 \approx 0.5599$
• 분모 계산:
  • 아이템 $b$를 본 5명의 편차 제곱합 : $\sqrt{5.2} \approx \mathbf{2.28}$
  • 아이템 $f$를 본 5명의 편차 제곱합 : $\sqrt{5.2} \approx \mathbf{2.28}$
• 최종 결과 ($S_{be}$) $= 0.5599 / (2.28 \times 2.28) \approx 0.5599 / 5.198399 \approx \mathbf{0.108}$

🟪 Python 구현 코드

import pandas as pd
import numpy as np

# 1. 데이터 정의: 행은 아이템(a~f), 열은 유저(A~L)
ratings = {
    'a': {'B': 4, 'D': 5, 'G': 5, 'J': 3, 'L': 1},
    'b': {'A': 3, 'C': 2, 'F': 4, 'I': 4, 'J': 5},
    'c': {'B': 5, 'C': 3, 'D': 4, 'F': 3, 'H': 2, 'I': 1, 'K': 4, 'L': 2},
    'd': {'B': 2, 'E': 4, 'H': 5, 'J': 4, 'K': 2},
    'e': {'A': 5, 'B': 3, 'G': 2, 'H': 4, 'I': 3, 'J': 4},
    'f': {'B': 4, 'E': 2, 'H': 3, 'J': 3, 'L': 1}
}
df = pd.DataFrame(ratings).T # 행/열 전환하여 아이템을 행으로 설정

# 2. 사전 계산 (Pre-calculation)
### 아이템별 평균 평점 계산
row_means = df.mean(axis=1)

### 모든 아이템의 에너지(편차 제곱합 루트) 미리 구하기
item_norms = {}
for idx in df.index:
    # 각 점수에서 평균을 뺀 편차(deviation) 구하기
    dev = df.loc[idx] - row_means[idx]
    # 편차 제곱합의 루트 계산 (결측치는 제외)
    item_norms[idx] = np.sqrt((dev.dropna()**2).sum())

# 3. 기준 아이템(b)와의 유사도 계산
### 기준값 고정 (루프 밖에서 선언하여 효율성 증대)
target = 'b'
results = {}

r_target = df.loc[target]
mean_target = row_means[target]
norm_target = item_norms[target]

### 유사도 계산
for other in df.index:
    r_other = df.loc[other]
    mean_other = row_means[other]
    norm_other = item_norms[other]

    # 분자: 공통 유저(Common Users)의 편차 곱 합산
    common_idx = r_target.notnull() & r_other.notnull()
    dev_target = r_target[common_idx] - mean_target
    dev_other = r_other[common_idx] - mean_other
    numerator = (dev_target * dev_other).sum()

    # 분모: 미리 계산된 두 아이템의 에너지를 곱함
    denominator = norm_target * norm_other

    # 최종 유사도 계산
    similarity = numerator / denominator if denominator != 0 else 0
    results[other] = round(similarity, 4)

print("아이템 b 기준 유사도 결과:")
print(results)

• Q1. 아이템 B에 대한 유저 H의 별점 예측 ($$r_{HB}$$)

  • 선정 아이템 : $d$ (유사도 0.1373), $f$ (유사도 0.1077)
  • 유저 H의 해당 아이템 평점 : $r_{Hd} = 5$, $r_{Hf} = 3$
  • 계산 과정 : $$\frac{(5 \times 0.1373) + (3 \times 0.1077)}{0.1373 + 0.1077} = \frac{0.6865 + 0.3231}{0.2450} \approx \mathbf{4.12}$$

  $\rightarrow$ 결과: 유저 H는 아이템 b에 약 4.12점을 줄 것으로 예측됩니다.

  ---

• Q2. 아이템 B에 대한 유저 B의 별점 예측 ($r_{Bb}$)

  • 선정 아이템 : $d$ (유사도 0.1373), $f$ (유사도 0.1077)
  • 유저 B의 해당 아이템 평점 : $r_{Bd} = 2$, $r_{Bf} = 4$
  • 계산 과정 : $$\frac{(2 \times 0.1373) + (4 \times 0.1077)}{0.1373 + 0.1077} = \frac{0.2746 + 0.4308}{0.2450} \approx \mathbf{2.88}$$

  $\rightarrow$ 결과: 유저 B는 아이템 b에 약 2.88점을 줄 것으로 예측됩니다.

1.2 User-Item Collaborative Filtering

• 유저 간의 유사도를 계산하여 user $x$가 item $i$에 내릴 별점을 가중평균으로 예측합니다.

$$r_{xi}=\frac{\sum_{y\in N}s_{xy}\times r_{yi}}{\sum_{y\in N}|s_{xy}|}$$

• $s_{xy}$: 유저 $x$와 유저 $y$사이의 유사도
• $r_{yi}$: 유저 $y$가 기존에 아이템 $j$에 내린 점수
• $N$: 유저 $x$와 유사한 유저들의 집합 (아이템 $i$를 평가한 유저들 중 상위 $K$명)

1.3 특징 및 한계

• Item-Item vs User-User:

  • 유저는 주관적이고 변동성이 크지만, 아이템은 속성이 안정적이어서 Item-Item 방식이 더 정확합니다.

• Lazy Learning:

  • 유사도 기반 Rating Prediction은 Lazy Learning에 해당합니다.
  • 미리 학습하지 않고, 추천 요청이 들어온 그 순간에 모든 유사도를 계산한다는 의미입니다.
  • 따라서, 데이터가 커질수록 실시간 연산량이 급증하여 비효율적입니다.
    

2. 모델 기반 Rating Prediction

• 수학적 모델(함수)을 학습하여 효율성과 정확도를 높이는 방식입니다.
• Lazy Learning 방법의 비효율을 해결하기 위한 접근 방법입니다.

1️⃣ 가장 단순한 모델 (Mean Model)

가장 단순한 모델?의 예측 함수는 다음과 같이 정의됩니다.

1.1 가장 단순한 모델의 구조

$$f(u, i) = \alpha$$

• input, output 상관없이 특정값을 반환하는 함수입니다,
• 이 목적함수를 최소화 하는 $\alpha$를 찾으면, 결국 평균(mean)을 의미하게 될 것d입니다.
• 왜 평균인가? 오차(MSE)를 최소화하는 지점을 미분으로 찾으면, 그 값은 항상 데이터의 평균에 수렴하기 때문입니다. (mse를 가장 줄이는 것은 평균)

2️⃣ Bias Model

단순히 유사도만 보는 것이 아니라, 유저와 아이템의 고유한 성향(편향)을 수학적으로 모델링합니다.

• 유저와 아이템의 고유한 성향 반영이 필요한 경우 예시
  • User Bias: 평소에 모든 영화에 1점만 주는 '박한 사람' vs 5점만 주는 '후한 사람'
  • Item Bias: <왕과 사는 남자>처럼 누구나 좋아해서 점수가 높은 영화 vs 호불호가 갈리는 영화

2.1 Bias 모델 구조

Bias 모델의 예측 함수는 다음과 같이 정의됩니다.

$$f(u, i) = \alpha + \beta_u + \beta_i$$

목적함수 구성 요소

1. $\alpha$ (Global Bias): 전체 시스템의 평균 별점
2. $\beta_u$ (User Bias): 사용자의 성향 (평점을 후하게 주는지, 박하게 주는지)
3. $\beta_i$ (Item Bias): 아이템의 성향 (대체로 높은 점수를 받는지, 낮은지)

2.2 Bias 모델의 목적함수 (규제항의 필요성)

모델은 실제값($R_{ui}$)과 예측값 사이의 오차를 줄이려 노력합니다. 하지만 데이터가 부족할 때 모델이 특정 편향을 무리하게 키우는 과적합이 발생하므로, 이를 방지할 규제항(Regularization)이 필수적입니다.

$$\arg \min_{\alpha, \beta} \sum_{u,i} (\alpha + \beta_u + \beta_i - R_{u,i})^2 + \lambda [\sum_u \beta_u^2 + \sum_i \beta_i^2]$$

이 식은 크게 두 부분으로 나누어 볼 수 있습니다.

A. 오차 제곱합 (Sum of Squared Errors) : $$\sum_{u,i} (\underbrace{\alpha + \beta_u + \beta_i}{\text{예측값}} - \underbrace{R{u,i}}_{\text{실제값}})^2$$

⇒ 의미: "내가 예측한 점수와 실제 유저가 준 점수가 얼마나 다른가?"를 잽니다. 이 값이 작을수록 실제 데이터와 잘 맞는 모델이 됩니다.

B. 규제 항 (Regularization Term) : $$\lambda [\sum_u \beta_u^2 + \sum_i \beta_i^2]$$

⇒ 의미: "모델이 너무 복잡해지거나 특정 유저/아이템에 과하게 맞춰지지(Overfitting) 마라!"라고 브레이크를 거는 장치입니다.

• $\lambda$ (람다): 규제의 강도를 조절합니다. 람다가 클수록 모델은 안전하고 보수적으로 변합니다.

💡 왜 규제가 필요한가?

모델은 가장 안전한 전체 평균(α)에서 출발합니다. 하지만 오직 현재의 오차를 0으로 만드는 데만 집착하는 모델은 다음과 같은 극단적인 선택을 합니다.

• 실제가 평균보다 클 때 ($R_{ui}>α$): 오차를 없애려고 β를 양수(+) 방향으로 깊숙이 보냅니다. (예: $β_u =+2.0$)
• 실제가 평균보다 작을 때 ($R_{ui} <α$): 오차를 없애려고 β를 음수(-) 방향으로 깊숙이 보냅니다. (예: $β_u =−2.0$)

문제는 데이터가 부족할 때입니다. 단 한 번의 평가만 보고 모델이 β를 0에서 너무 멀리 보내버리면, 그 유저나 아이템에 대해 "남들보다 무조건 2점 높다(혹은 낮다)"는 강한 편견을 갖게 됩니다. 이것이 바로 과적합입니다.

💡 규제항의 원리와 설계 의도

모델이 β를 0에서 너무 멀리 보내지 못하도록 목적함수에 $λβ^2$을 더합니다. 여기서 제곱을 쓰는 이유는 방향에 상관없이 '0으로부터의 거리'에 벌금을 매기기 위해서입니다.

• 방향 무관 벌금: β가 양수(+)로 멀어지든, 음수(-)로 멀어지든 제곱을 하면 모두 큰 양수(+) 벌금이 됩니다. 즉, "어느 방향이든 0(평균)에서 멀어지면 무조건 벌금이다!"라는 원칙입니다.
• 중심으로 당기는 힘: β가 0에서 멀어질수록 벌금($λβ^2$)이 제곱으로 폭등합니다.

🤖 모델 내부의 밀당 과정

e.g) 전체 평균이 3점인데 어떤 유저가 1점을 줬다면

• 모델의 유혹: "오차를 0으로 만들게 $β_u$를 $-2.0$ 로 보내버릴래!"
• 규제항의 경고: "어허, 0에서 그렇게 멀어지면 제곱 벌금이 $4$로 너무 커지는데?
• 모델의 타협: "음... 벌금이 너무 세네. 그냥 $β_u$를 $-0.5$ 정도로만 실제값 정도로 움직이고, 남은 오차는 그냥 감수하자. 그게 전체 점수 관리에는 유리해."

✅ 요약

결국 규제항($\lambda$)은 모델에 탄성력(고무줄)을 달아주는 것과 같습니다.

• 오차 제거: 실제 데이터 쪽으로 $\beta$를 당기는 힘 (예측을 정확하게!)
• 규제(벌금): 다시 평균(0) 쪽으로 $\beta$를 끌어오는 힘 (너무 튀지 않게!)

이 두 힘이 균형을 이루는 지점에서 가장 안정적인 $\beta$가 결정됩니다. 덕분에 데이터가 적은 상황에서도 모델이 미쳐 날뛰지(?) 않고 평균에 기반한 안정적인 예측을 할 수 있게 됩니다.

2.3 Bias 모델 최적화

(1) 경사하강법

함수의 기울기를 구하여 오차가 작아지는 방향(경사 아래)으로 파라미터를 조금씩 업데이트하며 최소값을 만드는 파라미터를 찾아가는 방식입니다.

(2) Alternating Least Squares(ALS)

변수가 여러 개($\alpha, \beta_u, \beta_i$)일 때, 한꺼번에 최적값을 찾기 어렵기 때문에 나머지 변수를 고정하고 하나씩 순차적으로 업데이트하는 방식입니다. 이를 반복하면 전체 오차가 최소화되는 지점에 수렴하게 됩니다.

2.4 특징 및 한계

Bias 모델은 개별 성향은 잘 파악하지만, "사용자가 특정 장르를 선호한다"와 같은 유저-아이템 간의 상호작용(Interaction)은 파악하지 못합니다. 이를 해결하기 위해 이후 Latent Factor Model(잠재 요인 모델)로 발전하게 됩니다.

3️⃣ Latent Factor Model

잠재 요인 모델

Bias 모델이 유저/아이템의 '평균적인 성향'만 봤다면, 잠재 요인 모델은 유저와 아이템 사이에 숨겨진 특징을 반영하는 모델입니다.

• Bias 모델의 한계: "아현님은 평소 5점을 잘 주고, 영화 <라라랜드>는 원래 인기가 많아"까지만 압니다. 유저와 아이템이 만났을 때 발생하는 '특수한 선호 관계'는 설명하지 못합니다.
• Latent Factor 모델의 목표: "아현님은 '로코 장르'를 좋아하고, <라라랜드>는 '로코 요소'가 강한 영화야. 그래서 둘이 잘 맞아!"라는 숨겨진 특징을 찾아내는 것입니다.

이러한 유저와 아이템의 속성을 벡터(Vector)로 표현하여 그들 사이의 특수한 선호 관계를 모델에 반영하는 것이 핵심입니다. 데이터(별점) 속에 숨겨져 있는, 무엇인지는 정확히 모르지만 분명히 존재하는 패턴을 찾아냅니다.

3.1 모델의 핵심 원리: 행렬 분해

수학적으로 이 벡터를 찾는 가장 정석적인 방법은 SVD입니다.

• SVD (Singular Value Decomposition): 행렬 $X$를 $U\Sigma V^T$라는 세 개의 행렬로 분해하여, 데이터의 핵심 특징만 남기고 나머지는 압축할 수 있다는 것을 수학적으로 증명한 정리입니다. 즉, 행렬을 쪼개서 적은 양의 정보로도 원본을 복원할 수 있습니다.

"거대한 평점 표(행렬)를 유저 벡터와 아이템 벡터의 곱으로 쪼개서 볼 수 있다"는 아이디어의 근거를 SVD에서 가져온 것입니다

즉, '유저 수 $\times$ 아이템 수'만큼의 엄청난 차원을 가진 원래 표를 우리가 정한 $k$개의 잠재 요인(Latent Factors)으로 압축하는 것이 목적입니다.

예제

출처: 국민대학교 박하명 교수님

• 별점 행렬 = 아이템 행렬 * 유저 행렬
  • 별점 행렬($6 \times 12$)이 두 개의 작은 행렬의 곱(Item Matrix $\times$ User Matrix)으로 표현되어 있습니다.
• 아이템 행렬 (Item Matrix):
  • 각 아이템(a~f)을 3개의 잠재 요인으로 요약한 벡터입니다.
  • e.g) 아이템 $c$의 벡터 $\gamma_c = [0.4, 0.2, 0.8]$.
• 유저 행렬 (User Matrix):
  • 각 사용자(A~L)가 그 3개의 잠재 요인을 얼마나 좋아하는지 나타낸 벡터입니다.
  • e.g) 사용자 $D$의 벡터 $\gamma_D = [0.1, 0.6, 0.7]$.
• 실제 별점 예측 과정: $f(u, i) = \gamma_u \cdot \gamma_i$
  • 이미지의 예시인 "사용자 $D$가 아이템 $c$를 보고 평점 얼마를 줄까?"
    • $$f(c, D) = [0.4, 0.2, 0.8] \cdot [0.1, 0.6, 0.7]$$계산 : $(0.4 \times 0.1) + (0.2 \times 0.6) + (0.8 \times 0.7) = 0.04 + 0.12 + 0.56 = \mathbf{0.72}$
    • 의미: 아이템 $c$가 가진 잠재적 속성들과 사용자 $D$가 선호하는 잠재적 취향을 내적하여 나온 이 점수가 바로 우리가 예측한 별점이 됩니다.

추천 시스템에서의 한계

하지만 추천 시스템에서는 이 SVD를 그대로 쓰기 어렵습니다.

1. 빈칸(Sparse) 문제 추천 데이터는 유저가 안 본 영화가 훨씬 많아 구멍이 숭숭 뚫려 있습니다. SVD는 빈칸이 있으면 계산이 안 됩니다.
2. 연산 효율 데이터가 거대해질수록 정통 SVD는 너무 느립니다. 원래 유저-아이템 행렬($R$)은 빈칸이 많은 거대한 행렬입니다. 이를 유저 행렬($P$)과 아이템 행렬($Q$)이라는 두 개의 작은 행렬로 쪼개는 것이 기본 원리입니다.

따라서 우리는 SVD의 수식을 그대로 푸는 대신, "빈칸은 무시하고, 이미 있는 값이라도 가장 잘 설명하는 벡터($\gamma$)들을 찾아내자"는 방식으로 아이디어를 발전시켜 사용합니다.

3.2 최종 예측 모델: "기본점수 + 알파"

그럼 구체적으로 latent factor 모델에 어떻게 반영할까요? SVD는 단 한 번의 복잡한 수식 연산으로 행렬을 쪼개지만 , MF는 최적화(Optimization) 과정을 거칩니다.

1. 초기화 : 유저 벡터($\gamma_u$)와 아이템 벡터($\gamma_i$)에 아무 숫자(랜덤값)나 채워 넣습니다. (당연히 처음엔 엉터리 점수를 예측하겠죠?)
   2. 예측 및 비교: 우리가 알고 있는 실제 점수($R_{u,i}$)와 두 벡터를 내적 해서 나온 점수($\gamma_u \cdot \gamma_i$)를 비교합니다.
   3. 오차 수정: "어라? 실제는 5점인데 내 모델은 2점이라고 하네?" 그러면 오차(3점)를 줄이는 방향으로 벡터 속의 숫자들을 아주 조금씩 수정합니다.

이 과정을 반복하면, 모든 유저와 아이템은 각각 고유한 숫자 묶음(벡터)을 갖게 됩니다.

이렇게 채워진 벡터와 아이템 벡터를 내적 해보면, 기존에 유저가 보지 않은 아이템에 대한 평점을 그럴싸하게 예측한 점수가 튀어나옵니다. 이것이 바로 잠재 요인 모델이 데이터 속에 숨겨진 유저의 취향 패턴을 '학습'했기 때문에 가능한 결과입니다!

위 과정을 수식으로 나타내보면 아래와 같습니다. 앞선 Bias 모델에 유저와 아이템의 상호작용 항을 더한 형태입니다.

즉, 유저와 아이템의 고유 성향(Bias)과 숨겨진 취향(Latent Factor)을 모두 결합한 최종 예측 모델입니다.

$$f(u, i) = \underbrace{\alpha + \beta_u + \beta_i}{\text{Baseline (기본 성향)}} + \underbrace{\gamma_u \cdot \gamma_i}{\text{Interaction (취향 케미)}}$$

• Baseline ($\mu + b_u + b_i$): 유저가 원래 후한지, 아이템이 원래 인기 있는지 같은 평균적인 성향(Baseline)을 잡아줍니다.
  • $\alpha$: Global baseline (전체 평균)
  • $\beta_u$: 사용자 $u$의 bias (사용자 성향)
  • $\beta_i$: 아이템 $i$의 bias (아이템 성향)
• Interaction ($\gamma_u^T \gamma_i$): 유저 벡터($\gamma_u$)와 아이템 벡터($\gamma_i$)의 내적값입니다. Baseline만으로는 설명할 수 없는 '유독 이 유저가 이 아이템을 좋아하는 이유'를 잡아내는 역할을 합니다. e.g) "이 유저는 액션을 좋아하는데($\gamma_u$), 이 영화는 액션 요소가 얼마나 들어있는가($\gamma_i$)"를 계산합니다.
  • $\gamma_u$: 사용자 $u$의 latent vector (사용자 잠재 요인)
  • $\gamma_i$: 아이템 $i$의 latent vector (아이템 잠재 요인)

3.3 목적함수와 규제항 (Regularization)

최적화의 구조는 Bias 모델과 똑같습니다. 오차(MSE)를 최소화하되, 파라미터들이 너무 튀지 않게 규제를 거는 원리입니다.

$$\arg \min_{\alpha, \beta, \gamma} \underbrace{\sum_{u,i} (\alpha + \beta_u + \beta_i + \gamma_u \cdot \gamma_i - R_{u,i})^2}{\text{Error}} + \underbrace{\lambda \left[ \sum{u} \beta_{u}^2 + \sum_{i} \beta_{i}^2 + \sum_{i} |\gamma_i|2^2 + \sum{u} |\gamma_u|2^2 \right]}{\text{Regularization}}$$

잠재 요인 모델에서도 목적함수에 규제항($\lambda |\gamma|^2$)이 추가됩니다. 이는 모델이 오차를 줄이려고 벡터 안의 숫자들을 무리하게 조정하는 것을 방지하기 위함입니다.

A. 오차 제곱합 (Sum of Squared Errors) : $$\sum_{u,i} (\alpha + \beta_u + \beta_i + \gamma_u \cdot \gamma_i - R_{u,i})^2$$

"내가 예측한 점수가 실제 별점($R_{u,i}$)과 얼마나 차이 나는가?"를 계산합니다.

B. 규제 항 (Regularization Term) : $$\lambda \left[ \sum_{u} \beta_{u}^2 + \sum_{i} \beta_{i}^2 + \sum_{i} |\gamma_i|2^2 + \sum{u} |\gamma_u|_2^2 \right]$$

"모델이 너무 복잡해지거나 특정 취향에 편향되지 마라!"라고 브레이크를 거는 장치입니다.

💡 $\beta^2$과 $|\gamma|_2^2$, 왜 형태가 다른가요?

두 기호는 모양만 다를 뿐, 본질적으로 "값이 평균에서 멀어지면 벌금을 매기겠다"는 원리가 똑같습니다. 단지 $\gamma$는 벡터(숫자 묶음)이라서 L2 Norm(제곱의 합)의 형태를 띠는 것입니다.

💡 왜 Latent Vector($\gamma$)에도 규제가 필요한가?

예시 )

• 잠재 요인을 3개($k=3$)로 잡았다면, 각 벡터의 숫자는 [액션, 로맨스, 영상미] 같은 숨겨진 특징들의 강도를 의미합니다.
  • 두 모델이 똑같이 0.3이라는 점수를 예측했다고 가정해 봅시다.
  • 모델 A (안정적)
    • 유저 벡터($\gamma_u$) : $[0.5, 0.5, 0.5]$
    • 아이템 벡터($\gamma_i$) : $[0.2, 0.2, 0.2]$

$⇒ [0.5, 0.5, 0.5] \cdot [0.2, 0.2, 0.2] = 0.3$

• 모델 B (불안정)
  • 유저 벡터($\gamma_u$) : $[1.0, 0, 0.5]$ (유저 벡터 값이 상대적으로 큼) "나는 액션을 매우 좋아하고(1.0), 로맨스는 관심 없고(0), 영상미는 조금 따져(0.5)" Error를 줄이는 데만 집착해서, 특정 벡터 값을 비정상적으로 크게 키워버린 경에 해당됨.
  • 아이템 벡터($\gamma_i$) : $[0.2, 0.2, 0.2]$

$⇒ [1.0, 0, 0.5] \cdot [0.2, 0.2, 0.2] = 0.3$

• 만약 아이템의 정보가 아주 살짝 바뀌어서 $\gamma_i$가 $[0.3, 0.2, 0.2]$가 된다면?
  • 모델 A : $[0.5, 0.5, 0.5] \cdot [0.3, 0.2, 0.2] = 0.35$ (기존 0.3에서 0.05 변화)
  • 모델 B : $[1.0, 0, 0.5] \cdot [0.3, 0.2, 0.2] = 0.4$ (기존 0.3에서 0.10 변화)

✅ 결론

• 특정 파라미터($\gamma$)의 절대값이 크면, 데이터가 아주 조금만 흔들려도 예측값이 요동치는 Fluctuation이 발생합니다.
• 규제항($\lambda ||\gamma||^2$)은 이 벡터들의 크기(L2 Norm)를 작게 유지시켜, 모델이 노이즈에 일희일비하지 않고 안정적으로 학습되도록 돕는 '고무줄' 역할을 합니다.

3.4 최적화 기법: ALS (Alternating Least Squares)

학습 과정에서 이 파라미터들을 찾는 것은 Bias 모델보다 훨씬 까다롭습니다. Bias 모델은 Convex(볼록)하지만, Latent 모델은 Non-Convex(비볼록)하기 때문입니다.

• Convex(볼록)와 Non-Convex(비볼록) 란?

  • Convex (볼록): 함수 모양이 매끄러운 '그릇' 모양인 경우. ⇒ 어디서 시작해서 내려가든 무조건 최솟값(Global Optimum, 전역 최적해)에 도착합니다.
  • Non-Convex (비볼록): 함수 모양이 울퉁불퉁한 모양인 경우. ⇒ 최솟값이라 생각하고 내려갔는데 알고 보니 작은 웅덩이(Local Optimum, 지역 최적해)에 빠져버릴 수 있습니다.

• 왜 Non-Convex인가? : 유저와 아이템의 "곱하기($\gamma_u \cdot \gamma_i$)" 때문입니다!

  • 더하기 ($x + y$): $x$와 $y$가 서로 간섭하지 않아 그래프가 매끄러운 그릇 모양을 유지합니다.
  • 곱하기 ($x \cdot y$): $x$를 키웠을 때 결과가 커질지 작아질지가 상대방인 $y$의 값에 따라 바뀝니다.
  • 이렇게 변수끼리 엉키는 '상호작용' 때문에 그래프가 울퉁불퉁한 산맥 모양이 되어 최적해를 찾기 어려워집니다.

• 그럼 어떻게 최적해를 찾는가? : 사용자 또는 아이템 행렬 중 하나를 상수로 고정하면 다시 Convex 형태로 만들 수 있습니다! 이를 활용하여 "번갈아 가며 $\gamma$를 고정합니다."

  1. 유저 벡터($\gamma_u$)를 고정하고, 아이템 벡터($\gamma_i$)를 최적화합니다.
  2. 아이템 벡터($\gamma_i$)를 고정하고, 유저 벡터($\gamma_u$)를 최적화합니다.
  • 장점:
    • 하나를 고정하는 순간 선형 회귀 문제로 바뀌어 풀기가 매우 쉬워집니다.
    • 유저별, 아이템별 계산이 독립적이라 병렬 처리(Parallelization)가 가능해 대규모 데이터에 유리합니다.

요약: 추천 시스템의 진화

1. 아이템 기반 / 유저 기반 CF: "이거 산 사람들이 이것도 샀어" (단순 통계)
2. Bias Model: "이 유저는 원래 좀 짜게 줘" (개인 성향 반영)
3. Latent Factor Model: "이 유저는 이런 '잠재적인 특징'을 가진 아이템을 좋아해" (숨겨진 취향 저격)

🛠 개발 환경

• 언어: Python
• 환경: Google Colab (대용량 데이터 처리에 최적!)
• Tip: VS Code 유저라면 'Google Colab' 확장을 통해 로컬에서도 편하게 연결할 수 있습니다.

💡 이전 포스팅

본격적인 실습에 앞서, 각 유사도 지표를 언제, 그리고 왜 사용해야 하는지 정리한 이전 포스팅을 먼저 읽어보시는 것을 추천드립니다.!

👉 유사도 측정 알고리즘 3종 세트: Jaccard, Cosine, Pearson

1️⃣ 데이터 준비 (Data Preparation)

https://grouplens.org/ https://grouplens.org/datasets/movielens/

먼저 GroupLens에서 제공하는 MovieLens-32M 데이터를 다운로드하고 압축을 해제합니다. 이후 CSV 파일을 읽어 파이썬의 dict 구조로 변환합니다.

# 데이터 다운로드 및 압축 해제
!wget https://files.grouplens.org/datasets/movielens/ml-32m.zip
!unzip ml-32m.zip

import csv
from tqdm import tqdm

movies = {}

# 1. 영화 기본 정보 추출 (movieId, title, genres)
with open('ml-32m/movies.csv', 'r', encoding='utf-8') as f:
    reader = csv.reader(f)
    next(reader) 
    for mid, title, genres in reader: 
        movies[int(mid)] = {
            'title': title,
            'genres': genres,
            'users': set(),
            'tags': set(),
            'ratings': {}
        }

# 2. Tag 정보 추출 (userId, movieId, tag)
with open('ml-32m/tags.csv', 'r', encoding='utf-8') as f:
    reader = csv.reader(f)
    next(reader)
    for _, mid, tag, _ in reader:
        mid_int = int(mid)
        if mid_int in movies:
            movies[mid_int]['tags'].add(tag)

# 3. Ratings 정보 추출 (userId, movieId, rating)
with open('ml-32m/ratings.csv', 'r', encoding='utf-8') as f:
    reader = csv.reader(f)
    next(reader)
    for uid, mid, rating, _ in reader:
        mid_int = int(mid)
        if mid_int in movies:
            uid_int = int(uid)
            movies[mid_int]['users'].add(int(uid))
            movies[mid_int]['ratings'][int(uid)] = float(rating)

2️⃣ 유사도 지표 정의 (Similarity Metrics)

추천의 핵심이 되는 유사도 알고리즘 두 가지를 정의합니다.

2.1 자카드 유사도 (Jaccard Similarity)

집합 간의 유사도를 측정합니다. 태그가 얼마나 겹치는지, 혹은 시청한 유저 목록이 얼마나 비슷한지 비교할 때 유용합니다.

$$J(A, B) = \frac{|A \cap B|}{|A \cup B|}$$

def jaccard_similarity(a, b):
    union_size = len(a | b)
    intersection_size = len(a & b)
    return intersection_size / union_size if union_size > 0 else 0

2.2 코사인 유사도 (Cosine Similarity)

평점과 같은 수치 벡터 사이의 각도를 측정합니다. 평가 패턴이 얼마나 유사한지 파악하는 데 적합합니다.

$$\text{similarity} = \cos(\theta) = \frac{\mathbf{A} \cdot \mathbf{B}}{|\mathbf{A}| |\mathbf{B}|}$$

def cosine_similarity(a, b):
    keys = a.keys() & b.keys() # 공통 유저
    if not keys: return 0

    nom = sum(a[k] * b[k] for k in keys)
    denom = (sum(v**2 for v in a.values()) * sum(v**2 for v in b.values()))**0.5
    return nom / denom if denom > 0 else 0

2.3 Centered 코사인 유사도 (Centered-Cosine Similarity / Pearson)

별점을 기준으로 유사도를 측정하는 경우, [Case 3] 유저마다 별점을 주는 기준(짜게 주는 사람 vs 후하게 주는 사람)이 다르기 때문에, 피어슨 상관계수를 사용하여 코사인 유사도를 구합니다.

1. 데이터 평준화 (Centering): 각 영화의 평균을 구하여 모든 평점에서 뺍니다.

   for movie in movies.values():
      avg = sum(movie['ratings'].values()) / len(movie['ratings'])
      movie['p_ratings'] = {uid: r - avg for uid, r in movie['ratings'].items()}

2. 교정된 평점으로 유사도 계산

   get_topk(152081, 10, key='p_ratings', similarity=cosine_similarity)

💡 참고) Centered-Cosine Similarity == Pearson ?

이 코사인 유사도 식에서 각 영화의 평균 평점을 뺀 뒤 계산하면, 그게 바로 피어슨 상관계수(Pearson Correlation Coefficient = Centered-Cosine Similarity)가 됩니다.

즉, 유저의 평점 편향을 제거하고 싶을 때 데이터를 먼저 Centering한 후 코사인 유사도를 적용하면 됩니다!

상세한 원리가 궁금하다면? "유사도 측정 알고리즘 3종 세트: Jaccard, Cosine, Pearson"에서 확인하실 수 있습니다. 작성하신 핵심 내용을 하나도 빠뜨리지 않으면서, 블로그 독자들이 한눈에 원리를 파악할 수 있도록 시각적 요소(LaTeX, 표, 인용구)를 활용해 예쁘게 다듬어 보았습니다.

🚀 왜 .corr()보다 직접 구현한 Centered Cosine이 더 정확할까?

판다스의 피어슨 .corr()은 두 영화를 공통으로 본 유저만 계산에 넣습니다. 이 경우 데이터가 적을 때 유사도가 1.0(완벽함)으로 튀는 '과장'이 발생하기 쉽습니다.

상황	데이터 규모	결과	신뢰도
상황 A	영화 X, Y를 딱 2명이 봄	피어슨 1.0	낮음 (우연일 확률 ↑)
상황 B	영화 X, Y를 10,000명이 봄	피어슨 1.0	높음 (진짜 인기작!)

컴퓨터는 둘 다 '완벽한 추천'으로 보겠지만, 우리는 상황 B가 훨씬 신뢰할 만하다는 것을 압니다. 우리가 직접 구현한 방식은 이 신뢰도 차이를 수학적으로 잡아냅니다.

👉 해결책: 평가 안 한 사람들을 분모에 참여시키기!

Centered Cosine은 평가하지 않은 수많은 유저를 '중립(0)'으로 계산에 참여시켜 일종의 브레이크 역할을 하게 합니다.

• 분자: 공통 유저의 취향 방향(패턴)만 반영합니다.
• 분모: 해당 영화를 본 전체 유저의 에너지(무게)를 모두 반영합니다.

  "Centered Cosine의 판단" *"X와 Y의 패턴이 겹치는 건 2명뿐인데, X를 본 전체 인원은 100명이네? 나머지 98명의 의견을 모르니까 함부로 1.0이라고 하지 말고 유사도를 0.1 정도로 확 낮추자."*

  즉, "안 본 사람들의 데이터(0)"를 분모에 참여시켜, 공통 유저가 적을수록 분모를 키워 유사도를 보수적으로 측정함으로써 추천 시스템의 안정성을 확보합니다.

  def cosine_similarity(a, b):
    """
    a, b: 영화 평점 딕셔너리 {user_id: centered_rating}
    """
    ### 1. 분자 (Numerator)
    # 두 영화 모두 평점이 있는 유저들의 취향 일치도 합산
    common_keys = a.keys() & b.keys()
    nom = sum(a[k] * b[k] for k in common_keys)
  >
  ### 분모
  # 평가를 한 모든 사람의 점수가 반영됨!! (일반 pearson으로만 계산하는 경우에는 평가가 있는 경우만 계산에 반영함)
  # 즉, 분자에선 모두 평가한 경우에 대해서만 반영하지만, 분모에서는 평가를 안 한 경우도 반영함.
  # pearson과 달리 분모를 커지게 함으로써 유사도를 낮춤으로써 안정화시킴
  # 추천시스템에선 빈 칸도 정보로서 활용하고자 하므로 - pearson보다 centered cosine 방식 사용이 더 정확함
  denom = (sum(v**2 for v in a.values())* sum(v**2 for v in b.values()))**0.5
  if denom == 0:
      return 0
  >  
  return nom/denom

💡 정리하자면 추천 시스템에서는 빈칸(NaN)조차 소중한 정보! 판다스의 피어슨보다 직접 구현한 Centered Cosine 방식이 빈칸의 존재감을 분모에 반영하여 훨씬 정교하고 안전한 추천 결과를 만들어냅니다!

3️⃣ Top-K 추천 엔진 구현

특정 영화를 기준으로 가장 유사한 상위 $k$개의 영화를 찾는 핵심 함수입니다.

def get_topk(target_mid, k=20, key='tags', similarity=jaccard_similarity):
    target_set = movies[target_mid][key]
    res = []

    for mid, movie in tqdm(movies.items()):    
        if target_mid == mid or not movie[key]: 
            continue

        score = similarity(target_set, movie[key])
        if score > 0:
            res.append((score, movie['title']))

    # 유사도 점수 기준 내림차순 정렬
    res.sort(key=lambda x: x[0], reverse=True)
    return res[:k]

4️⃣ 실전 활용 예시

Case 1: 태그 기반 내용 유사도 추천 (CBF)

"영화가 다루는 소재나 분위기가 비슷한 작품을 찾고 싶을 때"

# '152081' 영화와 키워드(tags)가 유사한 영화 상위 10개
get_topk(152081, 10, key='tags', similarity=jaccard_similarity)

Case 2: 시청 유저 기반 추천 (CF)

"이 영화를 본 사람들이 공통적으로 많이 본 다른 작품을 찾고 싶을 때"

# '152081' 영화를 본 유저(users)들이 많이 본 영화 상위 10개
get_topk(152081, 10, key='users', similarity=jaccard_similarity)

Case 3: 평점 기반 추천 (CF)

"평점이 유사한 영화를 찾고 싶을 때"

유저마다 별점을 주는 기준(짜게 주는 사람 vs 후하게 주는 사람)이 다르기 때문에, 피어슨 상관계수를 사용하여 코사인 유사도를 구합니다.

# 1. 피어슨 상관계수를 위한 데이터 Centering
for movie in movies.values():
    if not movie['ratings']: continue

    avg = sum(movie['ratings'].values()) / len(movie['ratings'])
    # 현재 영화 객체에 'p_ratings'라는 교정된 평점 데이터 추가
    movie['p_ratings'] = {uid: r - avg for uid, r in movie['ratings'].items()}

# 2. 교정된 평점으로 추천 실행
get_topk(152081, 10, key='p_ratings', similarity=cosine_similarity)

참고)

전처리가 완료된 movies 딕셔너리는 아래와 같이 원본 평점(ratings)과 교정된 평점(p_ratings)을 동시에 가지게 되어, 목적에 맞는 다양한 추천 전략을 구사할 수 있습니다.

movies = {
    101: {
        'title': '인터스텔라',
        'ratings': {1: 5.0, 2: 4.0},        # 원본 (0~5점)
        'p_ratings': {1: 0.5, 2: -0.5},    # 교정 (평균 4.5 차감)
        ...
    }
}

끝! 감사합니다~~

들어가기 앞서서, python 로고가 뱀인 것처럼.. java 로고가 커피인 이유가 궁금했는데 원래 이름은 'Oak'였는데, 상표권 이슈로 개발자들이 자주 마시던 자바 커피에서 이름을 따온 거라고 한다. 역시.. 개발자들은 커피를 달고 사는 운명인가부다..

1. 컴퓨터 프로그래밍 언어

1.1 프로그래밍 언어

1. 기계어 (Low-level Language)
   • 0,1 이진수로 된 언어
   • cpu는 기계어만 이해함
2. 어셈블리어 (Low-level Language)
   • 기계어 명령을 단어/기호로 매핑시킨 것
   • ex) ADD, SUB, MOVE
3. 고급 언어 (High-level Language)
   • 사람이 인지할 수 있는 언어
   • ex) java, C++, python
   • 절차 지향 언어 / 객체 지향 언어

1.2 컴파일 (Compile)

고급 언어로 작성된 소스 파일은 컴퓨터가 이해할 수 없으므로 번역 과정이 필요

전통적인 컴파일 (C, C++, Rust 등)

가상 머신 기반 컴파일 (Java, C# 등)

2. 자바 프로그래밍

• 과정: 소스 파일(.java) → (컴파일러javac) → 타겟 파일(.class) → (JVM 실행 시, → 기계어)

2.2 자바의 플랫폼 독립성 🌟

한 번 작성하면 어디서든 실행된다(Write Once, Run Anywhere)”

• 일반적인 C++ 등의 프로그램은 하드웨어에서 직접 실행해서 각기 다른 운영체제에 맞춰서 컴파일해야 하는 반면,
• Java는 JVM을 사용하여 가상으로 실행 가능하기 때문에, 운영체제에 관계없이 독립적으로 실행 가능

Java 실행 과정

_{JB = Java Bytecode(자바 바이트코드) = 컴파일된 .class 파일 출처 : https://youtu.be/OxvtGYvVkRU?si=M2vodliACaAZfkpu}

• Platform (=Hardware + OS) 위에 → JVM만 있으면 .class 파일(=바이트 코드, 타겟 파일)이 실행됨

• Hardware 위에 → OS 위에 → JVM을 설치하면 그 위에서 Java .class파일이 실행됨

• JVM 실행 = ".class 파일이 실행된다"

  JVM이라는 통역사가 .class라는 공통 설계도를 보고, 당신의 컴퓨터(Windows, Mac 등)에 딱 맞는 기계어로 실시간 통역하여 CPU에게 일을 시킨다

2.3 JVM (Java Virtual Machine)

• OS에 맞는 JVM이 설치되어 있다면, 동일한 .class 파일을 어디서든 그대로 실행할 수 있음
• 동적 로딩(Dynamic Loading): 실행 중 필요한 시점에 클래스를 로드하여 메모리 효율적임

JVM 실행 과정

2.4 (실습). 자바 프로그램 작성 및 실행

우리가 Hello.java를 작성하고 → javac로 컴파일하면, 바이트 코드가 담긴 .class 파일이 생성되는데, 이것이 컴파일 과정의 타겟 파일

1. 자바 파일 생성 (Hello.java를 작성)

    public class Hello {   // ① public '클래스' (파일당 1개만 가능)
        public static void main(String[] args) {   // ② public '메서드' (여러 개 가능)
            System.out.println("Hello, World!"); 
        }
    }

2. 자바 파일 컴파일 (javac)

    javac Hello.java  //컴파일하는 코드 "javac {파일명}.java"

- 소스코드 → 바이트 코드
- `javac Hello.java` → `Hello.class` (바이트 코드) 생성

```jsx
public static void main(java.lang.String[]);
    Code:
       0: getstatic     #2    // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #3    // String Hello
       5: invokevirtual #4    // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return
```

컴파일된 경우의 확장자는 class

3. JVM실행 (java)

   = .class 파일 실행

    java Hello //JVM 실행 코드 "java {파일명}"

   • 바이트 코드 → 기계어

   • JVM이 바이트코드를 읽어서 컴퓨터의 CPU가 알아들을 수 있는 기계어로 실시간 번역하며 명령을 내림

     10110010 00000000 00000010...

(추가) 디어셈블

  javap -c Hello > Helloc.bc 
  // javap -c {컴파일된 class파일의 파일명} > {저장할 파일명}.bc
  // JDK의 javap.exe 사용
  // 디어셈블된 결과 Hello.bc파일 생성

• 컴파일 된 .class 파일의 내용을 텍스트로 변환
• 즉, 클래스 파일에 있는 바이트 코드를 → just “텍스트”(소스코드X)로 볼 수 있게 하는 작업
• 대상: .class 파일 (이진수 바이트코드)
• 결과: JVM 명령어 (예: aload_0, getstatic, invokevirtual)
• 사용 도구: JDK에 포함된 javap
• 목적: JVM이 내부적으로 어떻게 동작하는지 분석할 때, 코드가 어떻게 최적화되었는지 확인하고 싶을 때

(추가) 디컴파일

• 컴파일된 .class 파일을 다시 .java 소스 코드로 복구
• 클래스 파일에 있는 바이트 코드를 → 소스코드로 볼 수 있게 하는 작업
• 대상: .class 파일 (이진수 바이트코드)
• 결과: .java 소스 코드 (예: public class Hello { ... })
• 사용 도구: JD-GUI, Jad, 또는 IntelliJ IDEA(자동 지원)
• 목적: 소스 코드를 분실했을 때 복구하기 위해, 다른 사람이 만든 라이브러리(.jar)가 어떻게 짜였는지 공부할 때

3. 자바 vs C++: 동작 방식 비교

JAVA

• 컴파일러가 바로 바이트코드한 후 링크 과정없음
• 바이트코드는JVM에서만실행 가능
• 자바는 필요한 클래스들을 프로그램 실행 중에 동적으로 로딩
• 동적로딩은 JVM에 포함된 클래스 로더에 의해 이루어짐
  • 동적 : 실행 시에
  • 정적(static) : 컴파일 시에 메모리에
• ClassLoader 클래스를 이용하여 개발자가 직접 클래스 로딩 가능

C++

• 목적 코드 및 실행 파일은 플랫폼에 따라 다름
• 플랫폼이 바뀌거나 다른플랫폼에서 실행시키려면 다시 컴파일 및 링크 → 보안에 약함

사실 학회 프로젝트로 끝날 수도 있었던 서비스가 진짜 유저를 만나기까지, '과연 세상에 나올 수 있을까?' 싶었던 순간들이 참 많았는데요. 정식 출시를 기념하며, 그동안의 과정들을 기록해 보려 합니다. 지난 학회 활동하면서는 몇 차례 회고를 남겼었어서, 지금까지 내용을 다시 한번 요약하고, 그 이후의 과정 위주로 기록해 보려 합니다.

1. 우리가 '함께' 모여야 하는 이유

서비스는 제 실제 니즈에서 출발했습니다. "왜 나는 집에서 혼자 작업할 때 집중하기 어려울까?"

저는 큐시즘 활동을 통해 모각작(모여서 각자 작업), 모각코(모여서 각자 코딩)를 처음 접하고 자주 참여했습니다. 하지만 매번 카페를 가기엔 비용이 부담스러웠고, 때로는 작업보다 잡담의 비중이 높아져 아쉬움이 남기도 했습니다. 그렇다고 집에서 혼자 하려니 유튜브를 보게 되거나 결국 다시 카페로 향하곤 했죠. 줌이나 디스코드는 카메라를 켜는 것이 부담스러웠고, 열품타는 랭킹 경쟁이 오히려 집중 흐름을 방해했습니다.

서로의 존재감은 느끼되 프라이버시는 지켜주는 실시간 온라인 작업실이 있으면 좋겠다고 생각했고, 모각작은 이런 갈증에서 태어났습니다.

2. 모각작이 실질적인 형태를 갖추기까지

초기 기획 단계에서는 '블러 조절을 통한 컴퓨터 화면 공유'를 주요 기능으로 고민하기도 했습니다. 하지만 한정된 개발 리소스를 고려했을 때, 현실적으로 구현 가능한 범위 내에서 서비스의 본질을 살리는 것이 최우선이었습니다. 그 결과, 유저들이 원하는 건 '부담은 없지만 함께하는 감각'이라는 결론에 도달했습니다.

리소스 문제로 피벗을 거쳤지만, 우리가 유지하고자 했던 핵심은 같습니다. 화면 블러 기능이 '함께 있음을 공유하되 직접적인 노출은 피하는 것'이었듯, 이를 타이머로 전환하여 함께 있음을 공유하면서도 작업 내용이나 참여 시간은 비공개할 수 있도록 설계했습니다.

이후 Usability Test(UT)와 전시회를 통해 서비스의 디테일을 구체화했습니다.

• UI의 일원화 (사이드바 개편): 처음에는 혼자 작업하게 되는 경우를 위해 '개인 타이머 페이지'를 따로 두었지만, 사용자들이 이용 방식에 혼란을 겪는 것을 발견했습니다. 이를 해결하기 위해 홈 화면과 그룹 방 어디에서든 동일하게 유지되는 '사이드바' 구조로 UI를 개편했습니다.
• 불필요한 기능의 삭제: "집중"을 위한 요소들 외 자잘한 기능들은 없앴습니다.
• 온보딩 프로세스 추가: 직관적인 UI라 가이드가 필요 없을 것이라 자신했지만, 실제 전시회에서 만난 유저들이 어려움을 겪는 것을 확인하고 정식 온보딩 과정을 추가하여 사용성을 높였습니다.

이 과정에서의 세세한 고민과 시행착오는 아래 기록들에 더 자세히 담아두었습니다. 서비스의 뼈대를 잡는 과정이 궁금하신 분들은 함께 읽어보셔도 좋습니다 :)

이전 기획 일지

• [1편] 기획 일지: 집중력을 설계하는 법
• [2편] 협업 방식 및 MVP 설정 스토리
• [3편] UT에서 발견한 반전 인사이트
• [4편] 데모데이와 전시회, 그 뜨거웠던 기록

[초기 UI] : 홈 & 그룹방 & 개인 타이머

초기에는 홈, 그룹방, 개인 타이머 세 가지 공간으로 나누어 기획했습니다.

홈 화면	개인 타이머	그룹방

[최종 픽스 UI] 개인 타이머가 사이드바로 통합된 홈 & 그룹방]

사용자 테스트(UT) 피드백을 반영해, 어디서든 내 상태를 관리할 수 있도록 개인 타이머를 사이드바로 통합했습니다.

홈 화면 (개인 타이머를 → 사이드바로 통합)	최종 그룹방

우리 디자이너들이 만든 캐릭터 넘 귀엽져!! >< 서비스를 사용할 수록 캐릭터들가 진화합니다!

3. 사이드 프로젝트 전환 후: 디테일과 안정성을 잡는 시간

학회 활동이 끝난 12월부터 '모각작'은 본격적인 사이드 프로젝트 체제로 전환되었습니다. 다행히 팀원 8명 모두 끝까지 함께해주었고, 백엔드 개발자 한 분을 추가 영입하여 이어갔습니다.

이 시기 동안에는 학회 기간 중 만든 초기 서비스를 다듬고 운영 안정성을 확보하는 데 집중했습니다. 릴리즈 이후 개선 지표로 활용할 데이터 수집 기반도 마련했습니다.

[12월~1월] 서비스 기반 재구축

• 백엔드 팀원 추가 영입 및 협업 체계 정비
• 방장 기능 및 개인정보 처리, 회원 탈퇴 기능 등 운영에 필수적인 디테일 구현
• 서비스의 첫 얼굴이 될 랜딩 페이지 제작
• 데이터 분석을 위한 GA 이벤트 로그 설계

[2월~3월] 단계별 QA 및 최적화

총 3차에 걸친 QA를 통해 내실을 다졌습니다.

• 1차 QA (내부): 개발된 기능들이 기획 의도대로 동작하는지 팀 내부에서 꼼꼼히 검증했습니다.
• 2차 QA (외부/베타): 베타 테스터를 모집하여 실제 유저 환경에서 발생하는 버그와 사용성 문제를 수집했습니다. 특히 제 지인 중에는 예향 언니가 실제 유저로서 정말 많이 사용해 주었는데, 덕분에 서비스의 가능성을 확인하고 큰 희망을 얻었습니다.ㅎㅅㅎ
• 3차 QA (최종): 베타 테스트 피드백을 반영한 최종 수정 사항을 내부적으로 마지막 점검했습니다.
• 소통 창구 마련: 유저와의 소통을 위한 FAQ 및 버그 제보 기능을 추가했습니다.
• SEO 최적화: 더 많은 유저가 검색을 통해 유입될 수 있도록 검색 엔진 최적화 작업을 진행했습니다. _{3차 대면 QA 했던 날!}

단순히 기능을 구현하는 단계를 지나, 실제 서비스가 돌아가기 위해 필요한 '현실적인 뒷면'들을 하나씩 채워 넣는 시간이었습니다. 유저가 탈퇴하고 싶을 때 바로 할 수 있게 만들고, 검색했을 때 우리 서비스가 잘 나오게 세팅하고, 혹시 모를 버그에 대비해 제보 창구를 만드는 일들 말이죠..ㅎㅎ

이 디테일들을 챙기면서, 비로소 서비스를 출시할 준비가 되었다는 확신을 얻었습니다!!(설렘)

특히 세 차례의 QA를 거치며 프론트엔드 담당 분량이 많았는데, 인원 보충 없이도 묵묵히 다 쳐내준 우리 프론트 팀원들에게 고맙다는 말을 슬쩍 남기고 싶네요.🥹 물론 우리 기디프백 팀원들 다 너무 고생 많았어요! 감사합니다!! ♥️🫶

4. 벨로그 유저를 위한 '모각작' 활용법

벨로그에는 각자의 성장에 몰입하는 분들이 많습니다. 모각작은 작업 흐름을 방해하지 않으면서도 적당한 긴장감을 주는 도구가 되고자 합니다. 또 모각작, 모각코에 익숙하신 분들이 많으실 것 같은데요. 이제 친구들과 온라인에서도 '모각작'을 해보세요! 이 글을 읽으시는 분들께 저희 '모각작'이 여러분의 작업 흐름에 방해가 되지 않으면서도, 적당한 긴장감을 주는 도구가 되길 바랍니다.

• 감시가 아닌 '존재감': 카메라를 켜거나 화면을 공유할 필요가 없습니다. 그저 누군가와 같은 시간에 각자의 할 일을 하고 있다는 사실만으로도 혼자일 때보다 훨씬 덜 딴짓하게 됩니다.
• 몰입을 돕는 심플한 도구: 복잡한 소통 기능은 덜어내고, 타이머와 상태 표시라는 본질에 집중했습니다. 다른 사람의 공부 시간을 랭킹으로 경쟁하기보다, 내가 오늘 계획한 시간을 채우는 것에만 집중해 보세요.
• 성장의 기록: 집중한 시간은 캘린더와 캐릭터 성장으로 기록됩니다. 이 데이터를 벨로그 TIL이나 회고록에 활용해 보셔도 좋습니다.

5. 마치며: 릴리즈, 그다음의 시작

드디어 정식 런칭을 했지만, 또 다른 도전이 시작됐네요! 이제부터의 목표는 이제부터 쌓일 데이터들을 보며 유저들이 어디서 불편해하는지 찾아내고, 하나씩 고쳐나가는 것입니다.

자잘한 일들이 쌓여 스트레스를 받거나 혼자 하는 작업이 유독 막막하게 느껴지는 날, 집중이 안 될 때 언제든, [모각작]에서 저희와 함께 몰입해 보시는 건 어떨까요?

👉 지금 바로 모각작 시작하기

** https://www.mogakjak.com/**

서비스 소식도 궁금하다면?

아래 채널에도 놀러 오세요!

• 공식 인스타그램: @mogakjak_official
• 모든 링크 모아보기: 모각작 링크트리

그 중 지난 시간에 모델을 분류 및 정리했었는데, 그중에서 모델의 학습 유무에 따른 분류를 했을 때, 학습된 인공지능이 추천하는 (model-based Approach)가 아니고, 직관적이고 구현이 용이한 Memory-based Approach(메모리 기반 접근 방식)에서 사용하는 유사도 계산법들을 정리해 보겠다.

1️⃣ 특징이 비슷한 아이템 찾기

아이템이 가진 고유 정보(장르, 키워드 등)를 비교해서 유사도를 계산할 땐, 어떤 알고리즘이 적합할까?

이때 사용하는 대표적인 방법은 자카드 유사도(Jaccard Similarity)이다. 각 작품들을 나타내는 단어,키워드들을 집합으로 수 있기 때문이다

▶️ Jaccard Similarity

두 집합 사이의 유사도를 측정하는 방법으로, (교집합의 크기) / (합집합의 크기)

🔵 예제

예시로 설명하기 위해 내 밥친구들 간의 유사도를 계산해보자! 임의로 각 작품들에 키워드를 선정했다.

• 무한도전: {예능, 코미디, 리얼버라이어티, 미션}
• 런닝맨: {예능, 게임, 리얼버라이어티, 미션}
• 크라임씬: {예능, 추리, 롤플레잉}

🟢 [자카드 유사도 계산 결과]

• 무한도전 vs 런닝맨:

  • {예능, 리얼버라이어티,미션} / {예능, 코미디, 리얼버라이어티, 미션, 게임}
  • 3 / 5 ≈ 0.6

• 무한도전 vs 크라임씬:

  • {예능} / {예능, 코미디, 리얼버라이어티, 미션, 추리, 롤플레잉}
  • 1 / 6 ≈ 0.16

• 런닝맨 vs 크라임씬:

  • {예능} / {예능, 게임, 리얼버라이어티, 미션, 추리, 롤플레잉}
  • 1/6 ≈ 0.16

⇒ 따라서, ‘무한도전’과 ‘런닝맨’의 유사도가 높은 것을 알 수 있다!

2️⃣ 암시적 데이터(Implicit Data) 활용

얼마나 클릭했는지와 같은 "양(Quantity)적"인 지표가 중요한 경우, 어떤 유사도를 사용해야 할까? 클릭 여부(O/X)처럼 이진(Binary)으로 표현되는 데이터는 이를 유저 집합으로 간주하여 이전 예제와 마찬가지로 자카드 유사도를 사용한다.

▶️ Jaccard Similarity

(교집합의 크기) / (합집합의 크기)

🔵 예제

아래와 같이 제품을 클릭한 유저들이 A~F까지 있을 때,

• 제품 X 클릭 유저: {A, B, D, E, F}
• 제품 Y 클릭 유저: {A, C, F}
• 제품 Z 클릭 유저: {A, B, D, F}

🟢[자카드 유사도 계산 결과]

• X vs Y :
  • 2 / 6 ≈ 0.33
• X vs Z :
  • 4 / 5 = 0.8
• Y vs Z :
  • 2 / 5 = 0.4

⇒ 따라서, X와 Z의 유사도가 높은 것을 알 수 있다!

🟪 [Python 구현 코드]

3️⃣ 명시적 데이터(Explicit Data) - 좋아요/싫어요

다음으로 '호불호'처럼 방향과 관련된 데이터의 경우, 데이터를 벡터(Vector)로 변환하여 코사인 유사도를 측정한다.

▶️ Cosine Similarity

두 벡터 사이의 각도를 측정하여 유사도를 구한다.

• 방향이 완전히 같으면 1 (취향 일치)
• 반대 방향이면 -1 (취향 정반대)

🔵 예제

데이터 치환: 좋아요(+1), 싫어요(-1), 미응답(0)

• X = [1, -1, 0, 1, 1, -1]
• Y = [-1, 1, 1, -1, 0, 0]
• Z = [1, 0, 0, 1, 0, -1]

🟢[코사인 유사도 계산 결과]

• X vs Y:
• X vs Z:
• Y vs Z:

  🟪 [Python 구현 코드]

4️⃣ 명시적 데이터(Explicit Data) - 별점(Rating)

별점/평점처럼 rating이 존재하는 데이터는 어떻게 처리해야 할까? 별점이나 평점처럼 수치가 존재하는 명시적 데이터는 단순히 숫자 크기만 비교할 경우 두 가지 함정에 빠지게 된다.

1. 미응답(Null) 데이터의 처리: 안 본 영화를 0점으로 처리하면 컴퓨터는 이를 '최악의 평점'으로 오해한다.
2. 주관적 기준에 따른 편향(Bias): 유저마다 별점을 주는 기준이 다르며, 아이템마다 기본적인 인기도가 다르다.

이 문제를 해결하기 위해 피어슨 상관계수(Pearson Correlation Coefficient), 즉 Centered Cosine Similarity를 사용한다.

▶️ Pearson Correlation Coefficient

(= Centered Cosine Similarity)

피어슨 상관계수는 코사인 유사도 공식의 각 데이터에서 '유저의 평균 평점'을 뺀 값을 대입하여 계산한다. 즉, Pearson Correlation Codfficient = Centered Cosine Similartiy 이다.

또한, 이전 예제들처럼 미응답을 단순히 '0'으로 채우거나 '평균'으로 채우는 것보다, 왜 피어슨 상관계수 방식이 더 유리한지 상세히 살펴보겠다.

❓ Null 채우기 전략 비교: 0 vs 평균 vs Zero-centering

미응답(Null) 데이터를 어떻게 채우느냐에 따라 추천 시스템의 성능과 변별력이 결정된다.

이제 아래 예제에 적용시켜보자!

🔵 예제

• X = [4, 2, 0, 4, 2, 1]
• Y = [4, 0, 4, 0, 0, 2]
• Z = [2, 5, 0, 2, 0, 4]

🟢 [피어슨 상관계수 유사도 계산 결과]

이미지의 Centered Matrix를 바탕으로, 코사인 유사도 공식 $U(x, y) = \frac{x \cdot y}{|x||y|}$을 적용해 계산하면 아래와 같다.

1. 데이터 평준화 (Zero-centering)

코사인 유사도를 구하기 전, 데이터에서 평균값을 빼는 '중심화(Centering)' 과정을 거친다.

이때, 무엇의 평균을 빼느냐에 따라 보정되는 편향의 종류가 달라진다.

• 유저 평균 차감 (Adjusted Cosine): 유저가 평소에 주는 평균 점수를 뺀다. 깐깐한 유저와 관대한 유저의 주관적 기준을 평준화한다.
• 아이템 평균 차감 (Centered Cosine): 영화가 받은 평균 점수를 뺀다. 원래 인기가 많아서 점수가 높은 영화와 비인기 영화 사이의 '인기 편향'을 제거한다.

아래 예제에서는 아이템 평균을 구해보겠다.

• Item X 의 평균: $[4, 2, 4, 2, 1] \rightarrow \text{평균} = 13/5 = 2.6$
• Item Y 의 평균: $[4, 4, 2] \rightarrow \text{평균} = 10/3 \approx 3.33$
• Item Z 의 평균: $[2, 5, 2, 4] \rightarrow \text{평균} = 13/4 = 3.25$

  ⚠️ 주의: 평균은 반드시 '평가한 항목'으로만 계산해야 한다. Null(미응답)을 미리 0로 고려해서 평균을 구하면 분모(데이터 개수)가 커져 평균값이 왜곡된다. 따라서 "평균 계산 → 중심화 → Null 채우기 순서"를 반드시 지켜야 한다.

각 점수에서 평균을 빼면 아래와 같은 Centered Matrix가 생성된다.

• X = [7/5, -3.5, 0, 7/5, -3/5, -8/5]
• Y = [2/3, 0, 2/3, 0, 0, -4/3]
• Z = [-5/4, 7/4, 0, -5/4, 0, 3/4]

2. 유사도 계산

($U = \frac{x \cdot y}{|x||y|}$)

① $U(X, Y)$ 계산

• 분자: $(1.4 \times 0.67) + (-0.6 \times 0) + (0 \times 0.67) + (1.4 \times 0) + (-0.6 \times 0) + (-1.6 \times -1.33) \approx \mathbf{3.06}$
• 분모:
  • $|X| = \sqrt{1.4^2 + (-0.6)^2 + 0^2 + 1.4^2 + (-0.6)^2 + (-1.6)^2} \approx \mathbf{2.68}$
  • $|Y| = \sqrt{0.67^2 + 0^2 + 0.67^2 + 0^2 + 0^2 + (-1.33)^2} \approx \mathbf{1.63}$
• 결과: $3.06 / (2.68 \times 1.63) \approx \mathbf{0.70}$ (양의 상관관계)

② $U(X, Z)$ 계산

• 분자: $(1.4 \times -1.25) + (-0.6 \times 1.75) + 0 + (1.4 \times -1.25) + 0 + (-1.6 \times 0.75) \approx \mathbf{-5.75}$
• 분모: $|X| \approx 2.68, |Z| = \sqrt{(-1.25)^2 + 1.75^2 + 0^2 + (-1.25)^2 + 0^2 + 0.75^2} \approx \mathbf{2.60}$
• 결과: $-5.75 / (2.68 \times 2.60) \approx \mathbf{-0.82}$ (강한 음의 상관관계)

③ $U(Y, Z)$ 계산

• 분자: $(0.67 \times -1.25) + 0 + 0 + 0 + 0 + (-1.33 \times 0.75) \approx \mathbf{-1.83}$
• 결과: $-1.83 / (1.63 \times 2.60) \approx \mathbf{-0.43}$ (음의 상관관계)

🟪 [Python 구현 코드]

import numpy as np

# Centered 데이터 (이미지 기반)
X = np.array([1.4, -0.6, 0, 1.4, -0.6, -1.6])
Y = np.array([0.67, 0, 0.67, 0, 0, -1.33])
Z = np.array([-1.25, 1.75, 0, -1.25, 0, 0.75])

def get_similarity(v1, v2):
    # 1. 분자: 내적 (Dot Product)
    dot_product = np.sum(v1 * v2)

    # 2. 분모: 각 벡터의 크기(Magnitude)
    mag1 = np.sqrt(np.sum(v1**2))
    mag2 = np.sqrt(np.sum(v2**2))

    return dot_product / (mag1 * mag2) if (mag1 * mag2) != 0 else 0

print(f"U(X, Y) = {get_similarity(X, Y):.2f}") # 0.70
print(f"U(X, Z) = {get_similarity(X, Z):.2f}") # -0.82
print(f"U(Y, Z) = {get_similarity(Y, Z):.2f}") # -0.43

🚀 왜 직접 구현한 Centered Cosine이 더 정확할까?

판다스의 .corr() 메서드는 공통으로 평가한 데이터만 계산에 포함한다. 이는 데이터가 적을 때 유사도가 1.0(완벽 일치)으로 과장되는 문제를 야기한다. 반면, 직접 구현한 방식은 다음과 같은 공학적 이점을 가진다.

1. 빈칸의 정보화: 중심화를 거치면 평균 점수가 0이 된다. 이때 빈칸을 0으로 채우는 것은 "해당 아이템에 대해 중립적인 의견을 가졌다"는 합리적인 가정이 된다.
2. 분모를 통한 신뢰도 보정: 분모 계산 시 해당 아이템을 평가한 전체 유저의 에너지를 반영한다. 공통 유저가 적을수록 분모가 커져 유사도가 보수적으로 측정되므로, 데이터 부족으로 인한 유사도 거품을 방지한다.

💡 핵심 요약

1. 평균 계산 기준: 공통 항목만 계산한다.

중심화(Centering)를 위해 평균을 구할 때 실제 점수가 있는 항목 수로 나누어야 유저의 주관적 평점 기준(후한지, 박한지)이 정확히 반영된다.

• 해석적 이유: 영화 '토이 스토리'를 본 100명이 모두 5점을 줬다면, 이 영화의 객관적인 품질은 5.0이다. 만약 안 본 유저 9,900명을 0점으로 넣어서 평균을 내면 0.05점이 되어버린다. 이 0.05는 영화의 품질이 아니라 '인기도'를 의미하게 되므로 평준화의 목적에 맞지 않다.
  • 중심화의 목적: 중심화의 목적은 "평균(보통)을 0으로 만드는 것"이다. 그래야 내가 준 4점이 남들보다 더 좋아하는 것(+)인지, 덜 좋아하는 것(-)인지 방향성이 생기기 때문!
  • 이유: 실제 평가 점수들로만 평균을 내야, 그 평균을 뺐을 때 비로소 0이 '딱 중간'이라는 수학적 의미를 갖게 된다.

    2. 유사도 계산 기준: 공통 항목만 계산하지 않는다.

    유사도 계산 시에는 0을 포함한 전체 벡터를 대상으로 해야 변별력 있는 결과가 나온다.

  • 분자 (내적): 어차피 한쪽이 0(미응답)이면 곱했을 때 0이 되어 사라져. 즉, 분자는 자동으로 '공통 유저'만 보게 된다.
  • 분모 (벡터 크기/Norm): 여기가 핵심! 분모에 0으로 채워진 빈칸들을 모두 포함시켜 벡터의 크기에 반영해야 한다.
  • 상황 A: 영화 X, Y를 공통 유저 2명이 똑같이 좋아함. (전체 유저도 딱 이 2명뿐임) $\rightarrow$ 분모가 작아서 유사도가 1.0 근처로 나옴.
  • 상황 B: 영화 X, Y를 공통 유저 2명이 똑같이 좋아함. (그런데 X는 1,000명이 봤음) $\rightarrow$ 분모가 엄청나게 커져서 유사도가 0.1 정도로 확 낮아짐.
  • 이유: 상황 B는 겨우 2명만 겹칠 뿐, 나머지 998명의 의견을 모르기 때문에 "이 유사도는 아직 믿을 수 없어!"라고 '데이터 부족에 대한 페널티'를 주기 위해서 이다.

    SUMMARY

    ⇒ 즉, 평균은 ‘데이터의 본질(질)’을 파악하기 위해 구하는 것이고, 유사도는 ‘데이터의 신뢰도(양)’를 반영하기 위해 구하기 때문에 범위의 차이가 발생한다!

    단계	고려 범위	목적	해석
    평균 계산	본 사람만	기준점 설정	"이 아이템/유저의 평소 수준은 이 정도다."
    유사도 분모	전체 유저	신뢰도 보정	"데이터가 적으면 우연일 수 있으니 점수를 깎자."

3. 한계점과 극복 (Scalability 문제)

앞서 피어슨 상관계수를 설명하며 미응답 데이터를 평균값으로 채우지 않고, 0으로 두는 이유가 메모리 효율성(Sparse Matrix 유지) 때문이라고 언급했다.

하지만 데이터의 규모가 유저 수백만 명, 아이템 수십만 개 단위로 커지면, 단순히 행렬을 비워두는 것만으로는 해결되지 않는 확장성(Scalability) 문제에 직면하게 된다.

🔴 왜 Sparse Matrix 유지방식만으로는 부족할까?

• 연산량의 폭주: 행렬이 비어 있어도, 유사도를 계산하기 위해 비교해야 할 유저나 아이템의 조합은 기하급수적으로 늘어난다. 실시간 추천이 불가능할 정도로 계산 속도가 느려진다.
• 정보의 희소성: 데이터가 너무 비어 있으면, 정작 유사도를 구하고 싶어도 공통으로 평가한 항목이 거의 없어 신뢰할 수 있는 결과를 얻기 어렵다.

즉, 이전에는 "빈칸을 억지로 채워서 메모리를 낭비하지 말자"는 차원이었다면, 이제는 "데이터의 차원 자체를 핵심만 남기고 줄여서 계산을 가볍게 만들자"는 고민으로 확장되는 것이다. 이를 해결하기 위해 차원 축소기술을 사용한다.

*🔴 주요 차원 축소 기술 (Dimension Reduction) *

• PCA (Linear): 데이터의 분산을 보존하며 선형적으로 차원을 축소.
• AutoEncoder (Non-linear): 딥러닝을 이용해 핵심 특징(Latent Factor)만 압축하여 추출. 복잡하고 정교한 유사도 파악 가능.

📝 Summary

참고로, CF도어떤 데이터냐에 따라 계산 방식이 다르듯, CBF도 데이터나 분석 목적에 따라 자카드 외에 다른 방식들도 있다. (아직 수업에서 안 배웠지만..) 예를 들어, 스마트폰 사양 비교 (배터리 용량, 무게, 가격)처럼 수치적인 차이를 알아야 할 때는 유클리드 거리, 완전히 동일한 단어는 아니더라도 유사한 의미의 단어가 있는 경우는 워드임베딩 등 !

목차

1. 추천시스템 분류 2. 추천시스템 Overview - 2.1 Challenges - 2.2 Data - 2.3 Models - 2.4 Evaluation

추천시스템을 처음 접했던 건 고3.. 빅데이터나 AI가 지금만큼은 아니지만 막 화두되고 있던 시기

이쪽으로 입시를 하기로 맘먹고, 관련 도서를 뒤적거리다가 원래 광고나 마케팅에도 관심이 있어서 자연스럽게 추천시스템이 끌렸다. 한창 넷플릭스의 추천 알고리즘이 떠올랐을 때라 넷플릭스 알고리즘 '시네매치'랑 아마존 추천 시스템을 비교하는 활동을 했었던 것 같다. 그러면서 collaborative filtering, cold start, long tail 등 용어를 처음 알게 됐었다.

그리고 휴학하면서는 서비스(모각작)를 만들었는데, 우리가 뭐 이커머스 같은 추천이 필요한 서비스는 아니지만, 그럼에도 이를 홍보하거나 SEO최적화를 할 때는 추천시스템에 대한 이해가 있으면 좋겠다는 생각을 하곤 했다.

그러다, 드디어 4-1인 이번에 "추천시스템 설계"라는 교과를 수강하게 되었다!! ㄷㄱㄷㄱ

대학교 내내 가장 로망이던 수업이라 무척 기대가 된다. 교수님도 휴학 전에 수업 들었던 교수님인데, 넘 좋아하는 교수님이라 너무 기대된다. 짧고 굵게, 동시에 재밌고 이해 쏙쏙 되게 설명해주시는 교수님이다~~ 아자스!!

앞으로 복습겸 주요 내용을 리뷰해보겠다. 오늘은 추천시스템에 대한 전반적인 개요!

1. 추천시스템 분류

여러 기준에 따라 분류가 가능하다

• 추천 형식
  • 별점/평점 예측, 추천 목록 나열 (순위 매기기)
• 사용 데이터
  • 별점 데이터, 간접 피드백 데이터
  • 유저 정보, 아이템 정보, 상황 정보
  • 관계 정보
• 추천 방법
  • collaboraitve filtering, content-based filtering
  • memory-base, model-based

2. 추천시스템 Overview

출처 : https://github.com/jihoo-kim/awesome-RecSys

2.1 Challenges

추천 시스템에서 고려해야 하는 challenge

• Bias : 한쪽으로 너무 치우치는 추천. 정확도가 높더라도 너무 한쪽 (e.g. 한 브랜드)만 하는 건 좋은 추천이 아님
• Fairness :
  • 사용자 측면: 성별, 인종, 연령 등에 따라 차별적인 추천을 하지 않는가?
  • 아이템 측면: 신규 판매자나 소외된 카테고리에도 노출 기회를 균등하게 제공하는가?
• Cold-Start problem : 처음 데이터가 충분치 않아서 적절한 추천을 하지 못하는 상황
• Filter Bubble : 확증편향, 점점 특정 분야로만 추천 (e.g. 강아지 릴스 시청 → 강아지 관련밖에 안뜸. 인스타는 커뮤니티 보다 강아지 앱이 되어버림)
• Security, Privacy

2.2 Data

데이터들의 유형

• User : 나이, 성별,,,
• Item : 제목, 이미지, 카테고리, 키워드,,,
• Context : 시간, 위치,,,
• User-Item Feedback
  • Explicit Feedback: 사용자가 직접적으로 자신의  선호도나 평가를 표현한 데이터
    • 예) 별점,리뷰,좋아요/싫어요
  • Implicit Feedback: 사용자의 직접적인 평가나 선호도 표현없이, 사용자의 행동으로부터 간접적으로 추론할 수 있는데이터
    • 예) 페이지조회수,구매이력,장바구니추가,스트리밍시간,  클릭기록

      User-Item Interaction Matrix (상호작용 행렬) 위에서 언급한 User와 Item 간의 피드백 데이터를 수학적으로 구조화한 것을 "User-Item Interaction Matrix, Utility Matrix, Rating Matrix" 등으로 부른다.

2.3 Models

알고리즘의 복잡도, 데이터 활용의 범위 등에 따라 Basic, Advanced 로 분류할 수 있다.

Basic 이번 학기엔 대부분 Basic models을 주로 배우게 된다

Basic 모델을 분류하는 기준에는 크게 두 가지 관점이 있다.

• 관점 1 : "어떤 정보를 사용"해서 선호를 추정하는지

  1. Collaborative Filteirng (CF) : ‘사용자-아이템 상호작용 데이터’를 사용해서 추천. "나와 비슷한 사람(User)_은 이것도 좋아하겠지?" 혹은 "_이 아이템을 산 사람은 저것도 사더라(Item)"

     왜 'collaborative' 라고 이름 붙였을까 생각해보면, 내가 영화 A를 보고 남긴 별점이 나와 취향이 비슷한 다른 사람에게 영화 A를 추천할지 말지 결정하는 중요한 근거가 되듯이, 데이터들이 서로의 추천을 돕는(collaborate) 구조라는 의미 같다.

  2. Content-base Filtering (CBF) : 아이템 속성(카테고리, 설명, 키워드, 장르)만을 사용해서 추천

• 관점 2 : "학습의 유무"

  1. memory-based Approach : 이전에 사용자가 봤던 영화와 비슷한 영화를 추천. 사용자/아이템 속성 간의 유사성을 직접 계산하여 추천

     Similarities

     • Cosine Similarity: 두 벡터 사잇각의 cosine 값.
       같은 방향(가까울수록) 1, 다른 반대 방향(유사도가 멀수록) 0
     • Pearson Correlation Coefficient  (CenteredCosineSimilarity): ???
     • Jaccard Similarity : 두집합의 합집합 크기 대비 교집합  크기 비율 → 이 3가지는 다음 포스팅에서 자세히 다루겠다!

  2. model-based : 인공지능이 파라미터를 학습해서 추천

Advanced

• Multi-Amed Bandit (MAB) : 이건 베이지안 통계 수업 때 자세히 배웠었는데, 활용과 탐색 두 가지 중 하나를 선택하며 최적을 찾는 모델이다.
  • 활용 : 지금까지의 데이터상 반응이 가장 좋았던 아이템을 보여주는 것.
  • 탐색 : 확신하기에 아직 데이터가 부족하지만 잠재력이 있는 새로운 아이템을 보여주는 것.

2.4 Evaluation

(1) 평가 환경 및 방법

[표 10] Instruction Finetuning을 수행한 LLaMA-I 모델의 MMLU 성능

• 기존 LLaMa-65B보다 성능이 오른 것을 확인할 수 있습니다. 다만 표에는 없지만 가장 최신 기술인 GPT code-davinci-002의 77.4보다는 낮습니다.

5. Bias, Toxicity and Misinformation

• 대규모 언어 모델은 훈련 데이터에 있는 편향을 그대로 재생산하거나, 유해한 콘텐츠를 생성할 수 있습니다.
• LLaMA-65B 모델도 웹에서 수집된 데이터를 훈련에 사용했기 때문에, 이런 문제를 일으킬 가능성이 있습니다.
• 우리는 모델이 유해한 콘텐츠나 고정관념을 생성할 가능성을 평가하기 위해 다양한 벤치마크를 사용했습니다.
• 이 평가들은 일부 표준 벤치마크를 사용하여 모델의 문제를 나타내지만, 모델과 관련된 모든 위험을 완전히 이해하기에는 불충분할 수 있습니다.

5.1 Real Toxicity Prompts

• 언어 모델은 모욕, 혐오 발언 또는 위협과 같은 유해한 언어를 생성할 가능성 있음
• 그러나 모델이 생성할 수 있는 유해한 콘텐츠의 범위는 매우 넓어, 이를 철저히 평가하는 것은 어움
• 이에 따라 최근 몇몇 연구에서 RealToxicityPrompts 벤치마크를 모델의 유해성을 평가하는 지표로 사용
  • RealToxicityPrompts: 약 10만 개의 프롬프트로 구성
  • 이 프롬프트를 완성하는 것이 모델의 과제, 그런 다음 생성된 텍스트의 유해성 점수는 PerspectiveAPI 3를 사용해 0(비유해)에서 1(유해) 사이로 자동 측정
• 해당 논문에서는 평균 유해성 점수를 측정
  • 결과는 문헌과 비슷하지만 일부 방법론적 차이 존재
  • 모델 크기가 커질수록, 특히 존중적인 프롬프트에서 유해성이 증가하는 경향이 관찰되었습니다.
  • Hoffmann et al.(2022)은 Gopher와 Chinchilla 사이에서 유해성 차이를 발견하지 못했는데, 이는 모델 성능의 차이 때문일 수 있습니다.

5.2 CrowS-Pairs

• 모델의 편향을 평가하기 위해 CrowS-Pairs 데이터셋 사용
  • CrowS-Pairs: 다양한 카테고리(성별, 종교, 인종/색, 성적 지향, 나이, 국적, 장애, 외모, 사회경제적 지위 등)에서 모델의 편향을 측정하는 데이터셋입니다.
  • 각 예제는 고정관념적인 문장과 반고정관념적인 문장으로 구성되어 있으며, 모델이 어느 쪽을 더 선호하는지를 측정
• LLaMA 모델은 평균적으로 GPT-3 및 OPT-175B 모델보다 약간 더 나은 성과
• 하지만, 종교 카테고리에서 LLaMA 모델의 편향이 특히 더 컸으며, 그 다음으로 나이와 성별 카테고리에서 편향이 나타남
• 이러한 편향은 CommonCrawl 데이터에서 기인했을 가능성이 있다고 예상

5.3 WinoGender

• 성별 카테고리에 대한 편향을 더 깊이 조사하기 위해 WinoGender 벤치마크 사용
• WinoGender: Winograd 스키마로 구성되어 있으며, 모델의 공동 참조 해석 성능이 대명사의 성별에 의해 영향을 받는지 평가
  • 구체적으로, 각 문장은 세 가지 요소를 포함합니다: "직업", "참가자", 그리고 대명사입니다. 대명사는 직업이나 참가자 중 하나를 참조합니다.
  • 따라서, 모델은 직업과 참가자를 참조하는 대명사를 올바르게 연결해야 함.
  • 이 테스트의 목표는 직업과 관련된 사회적 편향이 모델에 의해 얼마나 포착되었는지 밝히는 것!
    • 예를 들어, WinoGender 데이터셋의 문장 중 하나는 "The nurse notified the patient that his shift would be ending in an hour."입니다. 이 문장에서는 "His"가 누구를 가리키는지(간호사인지 환자인지)를 모델이 결정해야 합니다. 우리는 모델이 "nurse"와 "patient" 중 어느 것을 선택하는지, 그리고 그 선택에 따른 perplexity를 비교하여 공동 참조 해석을 평가합니다.
• LLaMA-65B 모델은 "their/them/someone" 대명사에서는 성능이 좋았지만, "her/her/she"와 "his/him/he" 대명사에서는 성능이 떨어짐.
• 이는 모델이 직업에 대한 사회적 편향을 반영하여 성별에 따라 잘못된 결정을 내리는 경우가 있음을 보여줌.
• "Gotcha" 사례에서는 대명사가 직업의 대다수 성별과 일치하지 않는데, 이때 모델이 더 많은 오류를 범합니다.
• 이 결과는 모델이 성별과 직업에 대한 편향을 가지고 있음을 명확히 나타냄.

5.4 TruthfulQA

• 모델의 진실성을 측정하기 위해 TruthfulQA 사용
  • 모델의 주장이 참인지 여부를 식별할 수 있는 능력을 평가하는 것
  • 잘못된 정보나 허위 주장을 생성할 위험성을 평가할 수 있음
  • 질문들은 다양한 스타일로 작성되었으며, 38개의 카테고리를 다루고 있고, 모델을 공격적으로 평가하기 위해 설계됨
• GPT-3와 비교했을 때, 우리의 모델은 두 카테고리에서 더 나은 성능
• 그러나, 여전히 정답률은 낮음 → 모델이 잘못된 답변을 생성(hallucination)할 가능성이 높음을 보여줌

Alpaca: A Strong, Replicable Instruction-Following Model

Meta의 LLaMA 7B 기반 모델

ABSTRACT

• instruction-following 능력을 가진 LLM을 학계가 재현할 수 있도록 만든 공개 프로젝트
• Meta의 LLaMA 7B 모델을 기반으로, OpenAI text-davinci-003이 생성한 52K instruction 데이터를 이용해 supervised fine-tuning함
• 예비 평가에서 text-davinci-003과 유사한 품질을 보이며, 생성비용은 약 $600 미만으로 저렴함
• 학계 연구자들이 접근 가능한 instruction model로서 의미 있음

1. INTRODUCTION

• instruction-following LLM(GPT-3.5, ChatGPT, Claude 등)은 점점 강력해지고 있음
• 하지만 오류(hallucination), 편향(stereotype), 유해 언어 등 여전히 한계 존재함
• 학계에서 이에 대한 연구 필요성이 크지만, 강력한 오픈소스 모델이 부족하여 연구 어려움
• 해결책으로 Stanford는 공개된 LLaMA 7B에 instruction 데이터셋을 활용하여 Alpaca 모델을 구축함
• 목표는 text-davinci-003과 유사한 성능을 가진 모델을 누구나 재현할 수 있게 만드는 것

2. TRAINING RECIPE

• 학술적 예산 하에 고성능 instruction 모델을 훈련하려면:

  • 강력한 사전학습 언어 모델 필요 → Meta의 LLaMA 시리즈 활용
  • 고품질 instruction 데이터 필요 → Self-Instruct 방식을 기반으로 text-davinci-003이 생성한 데이터 사용

데이터 생성 방식

• self-instruct seed로 제공된 175개 human-written instruction-output 쌍 활용
• 이를 기반으로 text-davinci-003에 in-context prompting으로 instruction 예시 생성
• 프롬프트 구조 단순화로 비용을 절감하며, 총 52K 쌍 생성 (OpenAI API 비용 약 $500)

모델 튜닝

• Hugging Face Transformers로 LLaMA 7B 모델을 fine-tuning
• Fully Sharded Data Parallel + mixed precision 훈련 적용
• 80GB A100 GPU 8개로 약 3시간 소요, 비용 약 $100

병렬 학습(Fully Sharded Data Parallel) 및 혼합 정밀도 학습(Mixed Precision Training)

3. PRELIMINARY EVALUATION

평가 방법

• self-instruct 벤치마크 세트에 대해 human 평가 수행
• 5명의 공동 저자가 blind pairwise 비교 (Alpaca vs text-davinci-003)
• 90 vs 89로 유사한 성능 결과 확인

분석 결과

• 작은 데이터와 모델 크기에도 text-davinci-003 수준의 성능을 보인 점이 인상적
• 상호작용 테스트에서도 다수의 입력에 대해 유사한 품질의 응답 생성 확인
• 다만, 평가 범위의 한계 존재하므로 대중과의 상호작용을 통해 피드백 수집이 중요하다고 판단함

4. KNOWN LIMITATIONS

• hallucination: 예) 탄자니아의 수도를 Dar es Salaam으로 잘못 응답함
• misinformation: 말은 그럴듯하나 잘못된 정보 생성 가능
• 기존 대형 언어 모델과 유사한 한계 포함됨
• instruction data 자체가 text-davinci-003 기반이므로 편향 전이 가능성 존재

5. ASSETS RELEASED

이미 공개됨

• Alpaca 7B 데모 (현재는 비활성화됨)
• 학습 데이터(52K instruction-output 쌍)
• 데이터 생성 코드
• 학습 코드 (Hugging Face 기반)

향후 공개 예정

• 모델 가중치 (Meta 측과 협의 중)

사용 조건

• LLaMA의 비상업 라이선스를 따르므로 상업적 이용 금지
• OpenAI text-davinci-003 기반 데이터 사용 → OpenAI 경쟁 모델 개발 금지
• Alpaca는 연구 목적에 한해 사용 가능

6. RELEASE DECISION

• 공개의 위험성도 고려함 (악용, 스팸, 허위정보 등)

• 하지만 학술적 연구의 재현성, 투명성, 안전성 향상이 더 큰 이점이라 판단

• 완전한 오픈 전에도 다음과 같은 위험 최소화 장치 마련함:

  • OpenAI content moderation API 활용한 필터 적용
  • Kirchenbauer et al. (2023) 방식의 워터마크 삽입
  • 명시적 이용 조건 설정

7. FUTURE DIRECTIONS

• HELM 등의 벤치마크로 더욱 정량적 평가 수행 예정
• red-teaming, auditing, adaptive testing 통한 안전성 향상 목표
• instruction 데이터 구성 요소의 중요성, base model 특성 등 체계적으로 분석할 예정
• Alpaca를 시작으로 다양한 open instruction LLM 연구를 촉진하고자 함

Chain-of-Thought Prompting

https://arxiv.org/abs/2201.11903

ABSTRACT

• 사고의 사슬(chain of thought)은 사고의 사슬 프롬프팅(chain-of-thought prompting)을 통해 구현한다
• 세 가지 대규모 언어 모델에 대한 실험을 통해 사고의 사슬 프롬프트가 다양한 산술, 상식 및 기호 추론 작업에서 성능을 향상시킨다는 것을 보여준다
  • 사고의 사슬 예시 8개만으로 PaLM 540B를 프롬프트 → 수학 단어 문제의 GSM8K 벤치마크에서 SOTA 달성, 미세 조정된 GPT-3를 능가

1. INTRODUCTION

• NLP의 최근 경향과 한계

  • 모델의 크기를 확장 → 성능과 샘플 효율성 향상
  • 그러나 모델 크기를 확장하는 것만으로는 산술, 상식, 기호 추론과 같은 어려운 과제에서는 높은 성능을 달성하기에 충분하지 않음.

• 기존에 LLM의 추론 능력을 활성화하는 방법과 그 한계

  1. 근거를 추가한 학습 및 미세 조정 방법

     • 산수 문제를 풀 때, 중간 과정을 자연어로 설명

     • 모델이 중간 추론 단계를 생성하도록 처음부터 훈련하거나, 기존 모델을 미세 조정

     • 자연어 대신 수학적 또는 형식적 언어를 사용

       ⇒ But, 고품질 자료를 많이 필요로 하기 때문에 비용이 많이 들고 복잡

  2. few-shot learning 프롬프트

     • 미세 조정하는 대신 작업을 보여주는 몇 가지 입력-출력 예시로 모델을 간단히 "프롬프팅" 가능

     • 특히, 간단한 질의응답 작업에서 좋은 성능 보임

       ⇒ But, 복잡한 추론이 필요한 작업에서는 효과적이지 않으며, 모델의 크기가 커지는 경우에도 성능 개선이 제한적

• 따라서 이 논문에서 제안하는 방식 - “chain-of-thought prompting”

  • 앞선 두 방법의 장점을 결합하면서 단점은 피하는 방안

  • 트리플로 구성된 프롬프트⟨입력, 생각의 사슬 , 출력⟩가 주어졌을 때 추론 작업에 대한 few-shot 프롬프트

  • 생각의 사슬은 최종 출력으로 이어지는 일련의 중간 자연어 추론 단계

    ⇒ 이 접근 방식을 생각의 사슬 프롬프트 라고 함

    예시) [그림 1 : Chain-of-thought prompting의 예시. LLM이 복잡한 산술, 상식, 기호 추론 작업을 처리할 수 있도록 함. 하이라이트 된 부분이 Chain-of-thought 추론 프로세스에 해당됨.]

• 의의

  • 산술(arithmetic), 상식(commonsense), 기호 추론 벤치마크(symbolic reasoning)에 대한 경험적 평가를 제시하여 표준 프롬프트(standard prompt)보다 성능이 뛰어남

  • 수학 단어 문제의 GSM8K 벤치마크 - PaLM 540B를 사용한 생각의 사슬 프롬프팅이 표준 프롬프팅보다 훨씬 뛰어난 성능을 보이며, SOTA 달성

    [그림 2: PaLM 540B는 사고의 사슬을 사용하여 수학 단어 문제의 GSM8K 벤치마크에서 새로운 최첨단 성능을 달성합니다.]

  • 프롬프트만을 사용하는 접근법이기 때문에, 큰 훈련 데이터셋이 필요하지 않음

  • 하나의 모델이 다양한 작업을 수행 가능

  • 몇 가지 예시와 함께 자연어 데이터를 통해 작업에 대해 학습할 수 있는 방법

    ⇒ 즉, 큰 훈련 데이터셋을 통해 입출력의 패턴을 자동으로 학습하는 것과 대비

2. Chain-of-Thought Prompting

• 복잡한 문제

  • 수학 단어 문제와 같은 복잡한 추론 과제
  • 이러한 복잡한 문제를 풀 때 나타나는 사고 과정을 고려
  • 문제를 중간 단계로 분해하고 최종 답을 제시하기 전에 각 단계를 푸는 것이 일반적
  • 이 논문의 목적은 언어 모델에도 이러한 단계적 사고와 유사한, 사고의 사슬을 생성할 수 있는 능력을 부여하는 것
  • 사고의 사슬은 문제에 대한 최종 답으로 이어지는 일관된 일련의 중간 추론 단계
  • 큰 언어 모델은 적절한 예시를 제공하면 생각의 사슬을 생성할 수 있음을 증명할 것
  • 생각의 사슬은 단계별 사고 과정을 모방하는 것을 강조한다는 의미에서 생각의 사슬로 정의

• 언어 모델 추론에 유용한 여러 특징

  1. 생각의 사슬은 복잡한 문제를 단계별로 분해 가능, 따라서 복잡한 문제의 각 단계마다 충분한 시간과 자원을 사용할 수 있음

  2. 모델의 사고 과정을 설명하므로, 오류를 찾는 데(디버깅) 유용 (그러나 모델의 계산을 완벽하게 이해하는 것은 아직 해결되지 않음)

  3. 수학 문제, 상식적 추론, 기호 조작과 같은 다양한 작업에 사용될 수 있으며, 인간이 언어를 통해 해결할 수 있는 모든 작업에 잠재적으로 적용될 수 있습니다(적어도 이론적으로는).

  4. 큰 언어 모델에서 쉽게 구현 가능

     몇 가지 짧은 프롬프트의 예시에 사고의 연쇄 시퀀스의 예를 포함시키는 것만으로도 사고의 연쇄적 추론을 이끌어내는 것이 가능

⇒ 경험적 실험을 통해 “산술적 추론, 상식적 추론, 기호적 추론” 을 위한 사고의 사슬 프롬프트의 유용성을 관찰할 것입니다 .

3. Arithmetic Reasoning

• 언어모델의 산술 추론 능력
• 산술 추론은 인간에게는 간단하지만 언어 모델에겐 까다로운 task
• 540B 매개변수 언어 모델과 함께 사용할 때 생각의 사슬 프롬프트는 여러 작업에서 작업별 미세 조정 모델과 비슷한 성능
• 까다로운 GSM8K 벤치마크에서도 SOTA 달성

3.1 Experimental Setup

[그림 3: ⟨입력, 생각의 사슬, 출력⟩의 예. 산술, 상식, 기호 추론 벤치마크를 위한 트리플. 사고의 사슬이 강조 표시]

여러 벤치마크를 통해 다양한 언어 모델에 대한 사고의 사슬 프롬프트를 탐구함

Benchmarks.

5가지 수학 단어 문제 벤치마크를 고려

(1) 수학 단어 문제의 GSM8K 벤치마크 ( Cobbe et al.,2021) 

(2) 다양한 구조를 갖는 수학 단어 문제의 SVAMP 데이터 세트 ( Patel et al.,2021)

(3) 다양한 수학 단어 문제의 ASDiv 데이터 세트 ( Miao et al.,2020)

(4) 대수 단어 문제의 AQuA 데이터 세트

(5) MAWPS 벤치마크 ( Koncel-Kedziorski et al.,2016) .

• 예제 문제는 부록 표  12

| 데이터 세트 | N | 예제 문제 |
| --- | --- | --- |
| GSM8K | 1,319 | 조쉬는 집을 뒤집기로 결심합니다. 그는 8만 달러에 집을 사고 5만 달러를 수리에 투자합니다. 이로 인해 집의 가치가 150% 상승했습니다. 그는 얼마나 많은 이익을 냈습니까? |
| **슈밤프** | 1,000 | DVD 한 팩은 76달러입니다. 각 팩에 25달러 할인이 적용된다면, 각 팩을 사려면 얼마를 지불해야 합니까? |
| ASDiv | 2,096 | 엘렌은 마린보다 공이 6개 더 많습니다. 마린은 공이 9개입니다. 엘렌은 공이 몇 개나 있습니까? |
| **아쿠아** | 254 | 자동차가 직선으로 일정한 속도로 수직 타워 바닥을 향해 운전되고 있습니다. 자동차에서 타워 꼭대기를 관찰하고, 이 과정에서 고도 각도가 45 *∘* 에서 60 *∘* 로 바뀌는 데 10분이 걸립니다 . 이 자동차가 타워 바닥에 도착하는 데 얼마나 더 걸리겠습니까? 답 선택지: (a) 53+ 1 (나) 63+2(다) 73- 1(d) 83- 2(e) 이 중 어느 것도 아님 |
| MAWPS: 싱글옵 | 562 | 상자에 병뚜껑이 7개 있고 린다가 병뚜껑을 7개 더 넣었다면, 상자에는 몇 개의 병뚜껑이 있을까요? |
| MAWPS: SingleEq | 508 | 베니는 2달러에 청량음료와 사탕 5개를 샀습니다. 그는 총 27달러를 썼습니다. 사탕 한 개당 얼마였습니까? |
| MAWPS: AddSub | 395 | 꽃병에는 장미가 6송이 있었습니다. 메리는 꽃밭에서 장미를 몇 송이 꺾었습니다. 이제 꽃병에는 장미가 16송이 있습니다. 그녀는 장미를 몇 송이 꺾었습니까? |
| MAWPS: 멀티아리스 | 600 | 학교 식당은 학생들의 점심으로 붉은 사과 42개와 녹색 사과 7개를 주문했습니다. 하지만 과일을 원하는 학생이 9명뿐이라면, 식당은 얼마나 더 많은 과일을 얻었을까요? |

Standard prompting.

• 비교 기준선:  Brown et al.에 의해 대중화된 표준 few-shot 프롬프팅
• 언어 모델은 테스트 시간 예제에 대한 예측을 출력하기 전에 입력-출력 쌍의 컨텍스트 내 예시를 제공합니다. 예시는 질문과 답변으로 형식화
• 그림  1 (왼쪽)

Chain-of-thought prompting.

• 몇 가지 샷 예시(few-shot exemplar)마다 연결된 사고 과정(chain of thought)을 추가하는 것
• 그림  1 (오른쪽)
• 연관된 답변에 대한 생각의 사슬로 few-shot 프롬프트의 각 예시를 증강
• 대부분의 데이터 세트에는 평가 분할만 있으므로 프롬프트를 위한 생각의 사슬이 있는 8개의 few-shot 예시 세트를 수동으로 구성
• 그림  1 (오른쪽)의 특정 예시는 프롬프트 엔지니어링을 거치지 않았습니다.
• 다양한 수학 단어 문제에서 성공적인 추론 유도 실험
  • AQuA를 제외한 모든 벤치마크에 대해 8개의 연쇄 사고 과정 예시 세트 사용
  • AQuA는 다지선다형 문제이기 때문에, 부록 표 21에 나와 있는 대로 훈련 세트에서 4개의 예시와 해답을 사용 [그림 1 : Chain-of-thought prompting의 예시. LLM이 복잡한 산술, 상식, 기호 추론 작업을 처리할 수 있도록 함. 하이라이트 된 부분이 Chain-of-thought 추론 프로세스에 해당됨.]

Language models.

• 다섯 가지 대규모 언어 모델을 평가

  1. GPT-3 (Brown et al.,2020) 

     ⇒ text-ada-001, text-babbage-001, text-curie-001 및 text-davinci-002를 사용하는데, 이는 아마도 350M, 1.3B, 6.7B 및 175B 매개변수의 InstructGPT 모델에 해당하는 것으로 보임

  2. LaMDA (Thoppilan et al.,2022) 

     ⇒ 422M, 2B, 8B, 68B, 137B 파라미터 모델

     • 시드 간 큰 변동을 보이지 않았기 때문에, 계산 자원을 절약하기 위해 다른 모든 모델에 대해서는 단일 예시 순서의 결과만 보고

  3. PaLM

     ⇒ 8B, 62B, 540B 파라미터 모델

  4. UL2 20B

  5. Codex

• 5개의 랜덤 시드에 대한 평균 결과를 보고

• 우리는 탐욕적 디코딩(greedy decoding)을 통해 모델에서 샘플링

  • 하지만 후속 작업에서는 여러 샘플링 세대에 걸쳐 최종 답변을 다수로 취함으로써 사고의 사슬 프롬프트를 개선할 수 있음을 보여줍니다 (Wang et al.,2022년)

3.2 Results

그림 4 : 연쇄 사고 유도의 효과

1. 작은 모델에서는 큰 효과 X

   • 작은 규모의 모델이 유창하지만 비논리적인 사고 과정을 생성하여 표준 프롬프트보다 낮은 성능
   • 약 100B 파라미터의 모델에서 사용될 때만 성능 향상 [그림 4: 사고의 사슬을 촉구하는 것은 대규모 언어 모델이 어려운 수학 문제를 풀 수 있게 해줍니다. 특히 사고의 사슬 추론은 모델 규모를 늘리는 새로운 능력입니다. 이전의 최고 수치는 Cobbe et al.에서 나왔습니다. ]

2. 더 복잡한 문제에 대해 더 큰 성능 향상

   • GSM8K(기준 성능이 가장 낮은 데이터 세트)의 경우 가장 큰 GPT 및 PaLM 모델에서 성능이 두 배 이상 향상
   • MAWPS의 가장 쉬운 하위 집합인 SingleOp의 경우, 해결하는 데 단계가 하나뿐이어서 성능 향상이 부정적이거나 매우 미미

3. 큰 모델들이 연쇄 사고 유도로 최고 성능에 도달하거나 근접

   • GPT-3 175B와 PaLM 540B에 COT 한 것은 fine-tuning 한 성능과 유사

   • PaLM 540B 모델이 여러 데이터셋(GSM8K, SVAMP 및 MAWPS)에서 새로운 최고 성능 기록

     다른 두 데이터 세트인 AQuA와 ASDiv에서 사고의 사슬 프롬핑을 사용한 PaLM은 최신 상태의 2% 이내에 도달합니다(부록 표  2 ).

⇒ 해결해야 하는 단계가 여러 개인 경우 효과적, 따라서 큰 모델인 경우에 성능 확실

• COT 효과 분석

  • GSM8K에 대해 LaMDA 137B로 모델에서 생성된 chains of thought를 수동으로 검사

  • 모델이 최종 정답을 반환한 50개의 무작위 예시 분석

    → 대부분의 사고 과정이 논리적이었으며, 두 개의 예시만 우연히 정답에 도달했습니다.

  • 틀린 답을 제공한 50개의 무작위 샘플을 무작위로 검사

    → 46%의 사고 과정은 사소한 실수(계산기 오류, 기호 매핑 오류 또는 추론 단계 하나 누락)를 제외하고 거의 정확

    → 나머지 54%는 의미적 이해 또는 일관성에 중대한 오류

• 스케일링이 COT 성능을 개선 시키는 이유 분석

  • 모델의 크기를 키우면 오류가 줄어듦
  • PaLM 62B에서 발생한 오류와 PaLM 540B로 스케일링하여 해당 오류가 수정되었는지 실험
  • 요약하면, PaLM을 540B로 스케일링하면 62B 모델에서 한 단계 누락 및 의미 이해 오류의 상당 부분이 수정됩니다( 섹션  A.1 참조 ).

3.3 Ablation Study

사슬 사고 프롬핑을 사용하는 관찰된 이점이 효과를 다른 프롬프트 유형에서도 얻을 수 있는지 조사

그림 5에서 세 가지 다른 방법으로 실험한 결과

Equation only.

• 모델이 답을 제시하기 전에 방정식만 출력하도록 한 것

• GSM8K에서는 방정식만 사용한 프롬프트가 큰 효과가 없었음

• 즉, GSM8K의 질문 의미론은 생각의 사슬에서 자연어 추론 단계 없이 방정식으로 바로 변환할 수 없음을 의미

  → 문제의 의미를 이해하고 해석하는 과정이 필요

• 그러나 단계가 적은 문제의 경우 '오직 방정식만'이 성능을 향상 시킴

  • 한두 단계로 해결할 수 있는 간단한 문제에서는 방정식만으로도 성능이 좋아짐
  • 왜냐하면 방정식을 질문에서 쉽게 파생할 수 있기 때문

그림 5:[LaMDA 137B 및 PaLM 540B를 사용한 다양한 프롬프팅 변형에 대한 절제 연구. 다른 데이터 세트에 대한 결과는 부록 표  6]

Variable compute only.

• 더 어려운 문제에 더 많은 계산(즉, 중간 토큰)을 사용할 수 있게 하는 것
• COT의 효과와 분리하기 위해, 필요한 문자 수만큼 점(...)을 출력하도록 모델을 설정
• (…)은 문제를 해결하는 데 필요한 방정식의 문자 수와 동일
• 이 변형은 기준선과 거의 같은 성능

⇒ 이는 변수 계산 자체가 사고의 사슬 프롬프트의 성공 이유가 아님을 알 수 있음

⇒ 또한, 자연어로 중간 단계를 표현하는 것이 더 유용함

Chain of thought after answer.

• 기존에는 연쇄 사고를 사용하여 문제를 푼 후 → 답을 제시하기 때문에,

  답을 내기 전에 연쇄 사고가 필요하지 않은지 확인

• 모델에게 답을 먼저 내고 나서 → 사고 과정을 설명하게 하는 방법을 사용

• COT 프롬프트는 모델이 사전 학습에서 배운 지식을 더 잘 활용할 수 있게 함

• 단순히 이러한 프롬프트를 통해 모델이 사전 훈련 중에 습득한 관련 지식에 더 잘 접근할 수 있다

• 우리는 사고의 사슬 프롬프트가 답변 이후에만 주어지고, 모델이 실제로 최종 답변을 제공하기 위해 생성된 사고의 사슬에 의존하는지 여부를 분리하는 대체 구성을 테스트

• 이 변형은 기준선과 거의 같은 성능

⇒ COT는 학습된 것을 떠올리는 것만이 아니라, 논리적으로 문제를 해결하는 과정에서도 유용

3.4 Robustness of Chain of Thought

• 프롬프트 방법의 중요한 고려사항 중 하나는 예시(exemplar)에 대한 민감도
  • 예시의 순서를 바꾸는 것만으로도 모델의 성능이 크게 달라짐
  • 예를 들어, 소수 샷 예시의 순열을 변경하면 SST-2에서 GPT-3의 정확도가 거의 우연(54.3%)에서 거의 최신 기술(93.4%)까지 변동 가능
• 따라서 서로 다른 사람들이 작성한 연쇄 사고가 얼마나 강건한지(일관된 성능을 보이는지) 평가
  • 위의 결과 외에도, Annotator A가 작성한 연쇄 사고를 사용하여, 이 논문의 두 명의 다른 공동 저자(Annotators B와 C)가 같은 몇 개의 샷 예시를 위해 독립적으로 연쇄 사고를 작성했습니다(부록 H에 나와 있음).
  • 또한, Annotator A는 기존보다 더 간결한 스타일로 연쇄 사고를 작성
• GSM8K 및 MAWPS에서 LaMDA 137B에 대한 결과 : 그림  6
• 다른 사람들이 작성한 연쇄 사고는 조금씩 차이가 있었지만, 그 어떤 방식이든 간에 모두 기본적인 방식(연쇄 사고를 사용하지 않은 경우)보다 훨씬 좋은 성능

⇒ 생각의 사슬을 성공적으로 사용하는 것이 특정 언어 스타일에 의존하지 않는다

[그림 6: 생각의 사슬을 촉구하는 방식은 예상대로 다양한 촉구 사례에 따라 차이가 있지만, 다양한 주석자 및 다양한 예시에 대해서는 표준 촉구 방식보다 더 나은 성과를 보입니다.]

• 다른 표본 세트에서도 효과적인지 확인

  • 독립적인 소스인 GSM8K 훈련 세트에서 무작위로 샘플링한 8개의 표본 세트 3개로 실험을 수행

  • 그림 6에서 무작위 예시도 수동으로 작성한 예시들처럼 좋은 성능을 보임

  • 다양한 변수들에도 불구하고 연쇄 사고 유도가 일관된 성능을 보인다는 것을 확인했습니다.

  • 다양한 변수들에도 불구하고 연쇄 사고 유도가 일관된 성능을 보인다는 것을 확인했습니다.

    → 주석자에 대한 강건성 외에도, 독립적으로 작성된 연쇄 사고, 다른 예시, 다양한 언어 모델에 대해, 산술 추론을 위한 연쇄 사고 유도가 다양한 예시 순서와 예시 수에도 강건함

4. Commonsense Reasoning

• 사고의 사슬은 수학 단어 문제에 특히 적합
• 그러나 일반적인 배경 지식을 전제로 물리적 및 인간 상호 작용에 대한 추론 등 상식적 추론 문제에도 적용 가능
• 상식 추론은 세상과 상호 작용하기 위한 중요한 요소이지만, 자연어 이해 시스템이 아직 완벽히 해결하지 못한 영역

Benchmarks.

• 상식적 추론 유형을 포괄하는 5가지 데이터 세트를 고려

  1. CSQA (Talmor et al.,2019)

     세상에 대한 상식적인 질문을 던지며, 이를 답하려면 복잡한 이해와 사전 지식이 필요

  2. StrategyQA (Geva et al.,2021) 여러 단계로 나뉜 전략을 생각해서 답을 찾아야 하는 문제들

  3. BIG-bench 프로젝트에서 두 가지 평가 세트를 선택

     1. Date Understanding : 문맥에서 날짜를 유추하는 문제
     2. Sports Understanding : 스포츠 관련 문장의 타당성을 판단하는 문제

  4. SayCan : 자연어 명령을 로봇이 실행할 수 있는 행동으로 변환하는 문제

Prompts.

• 이전 섹션과 동일한 실험 설정

1. CSQA와 StrategyQA의 경우

   → 훈련 세트에서 무작위로 예를 선택

   → 수동으로 사고의 사슬을 구성하여 몇 가지 샷 예시로 사용

2. 두 개의 BIG-bench 작업에는 훈련 세트가 없음

   → 처음 10개를 예로 삼고 나머지 데이터를 평가에 사용

3. SayCan

   → Ahn et al.에서 사용한 훈련 세트에서 6개의 예를 사용\

   → 또한 수동으로도 구성

Results.

• PaLM 모델에 대한 (상식 추론) 결과: 그림  7

• (LaMDA, GPT-3 및 다양한 모델 척도에 대한 전체 결과는 표  4 에 표시됨 ).

• 모델 크기를 키우면 성능이 좋아지고, 연쇄 사고 프롬프트를 사용하면 추가로 성능이 향상

• 특히, PaLM 540B 모델에서 가장 큰 성능 향상

  • PaLM 540B 모델은 연쇄 사고 프롬프트로 StrategyQA에서 이전 최고 성능보다 더 좋은 결과를 냈습니다.

  • 스포츠 관련 문제에서도 PaLM 540B 모델이 인간보다 더 나은 성과를 보였습니다.

    ⇒ 연쇄 사고 유도가 상식 추론 문제에서도 유용하다는 것을 보여주지만,

    ⇒ But, CSQA에서는 그 효과가 크지 않았음

그림 7: 생각의 사슬을 촉구하는 것은 또한 언어 모델의 상식적 추론 능력을 향상시킵니다. 여기에 표시된 언어 모델은 PaLM입니다. 이전의 최고 숫자는 CSQA (Talmor et al.,2019) 및 StrategyQA (Geva et al.,2021) (단일 모델만 해당, 2022년 5월 5일 기준). 다양한 크기의 LaMDA, GPT-3 및 PaLM을 사용한 추가 결과는 표  4 에 나와 있습니다 .

5. Symbolic Reasoning

• 인간에게는 간단하지만 언어 모델에게는 도전적인 상징적 추론(symbolic reasoning)을 다룸
• 논리적인 규칙을 따르는 문제
• chain-of-thought prompting를 사용하면 AI 모델이 더 잘 사고하고, 훈련 중에 보지 못한 새로운 문제도 잘 풀 수 있다
• 훈련 중에 보지 못한 더 긴 문제를 풀 때, 표준 프롬프트(단순히 답만 찾게 하는 방법)로는 잘 못 풀었지만, 연쇄 사고 유도를 사용하면 더 잘 풀 수 있음

Tasks.

두 가지 간단한 과제를 사용

1. 마지막 글자 연결(Last letter concatenation).

   이 작업은 모델에 이름의 단어의 마지막 글자를 연결하도록 요청 (예: *"Amy Brown").* → “yn” ).

   • 첫 글자 연결은 언어 모델이 생각의 연쇄 없이도 수행 가능함
   • 그러나 마지막 글자 연결은 이보다 더 어려움
   • 우리는 이름 인구 조사 데이터( https://namecensus.com/ ) 에서 상위 1,000개의 이름과 성에서 이름을 무작위로 연결하여 전체 이름을 생성

2. 동전 던지기(Coin flip). 

   이 과제는 사람들이 동전을 던지거나/ 던지지 않은 후에도 동전이 여전히 앞면인지 모델에 답하도록 요구 (예: *"동전이 앞면입니다. 피비가 동전을 던졌습니다. 오스발도는 동전을 던지지 않았습니다. 동전이 여전히 앞면인가요?"* → *"아니요"* ).

• 이러한 상징적 추론 과제들은 명확히 정의되어 있음

• (in-domain) 테스트 세트와 (out-of-domain) 테스트 세트 고려

  • (in-domain) 각 과제에 대해 훈련/소수 샷 표본과 동일한 단계 수를 갖는 예제가 있는 도메인 내 테스트 세트
  • (out-of-domain)  (OOD) 평가 예제가 표본의 단계보다 많은 단계가 있는 도메인 외 테스트 세트
  • OOD 예시:
    • 모델은 처음에는 두 단어로 된 이름만 보고 학습하고, 그 후에는 세 단어, 네 단어 이름의 마지막 글자 연결을 시도
    • 동전 던지기 문제도 뒤집는 횟수를 늘려가며 실험

• 실험 설정은 이전 두 섹션과 동일한 방법과 모델을 사용

• 그림  3 에 나와 있는 각 작업에 대한 소수 샷 표본에 대한 사고의 사슬을 다시 수동으로 구성

  

Results.

• in-domain 및 OOD 평가의 결과는 PaLM에 대한 결과: 그림  8
• LaMDA에 대한 결과: 부록 표  5
  • PaLM 540B를 사용하면 사고의 사슬 프롬프트로 거의 100%의 해결률
  • 표준 프롬프트로도 PaLM 540을 사용하여 동전 던지기를 이미 풀 수 있지만, LaMDA 137B의 경우는 그렇지 않음.
• 동일 도메인 문제 평가 (in-domain)
  • 이미 해결 방법이 주어져 있어서, 모델이 해야 할 일은 새 문제에서 같은 방법을 사용하는 것
  • 모든 모델은 테스트 시간 예제에서 새 기호로 동일한 단계를 반복하기만 하면 됨
  • 그러나 작은 모델은 여전히 실패 → 이 문제들을 해결하려면 모델이 매우 커야 함. (100B 모델 매개변수의 규모)
• 도메인 외 평가 (OOD)
  • OOD 평가에서는 표준 프롬프트가 두 작업 모두(마지막 이름, 동전 던지기)에서 실패
  • 연쇄 사고 프롬프트가 더 나은 결과
  • 모델의 크기가 커질수록 성능이 더 좋아진다
  • 그러나, in-domain 성능 보다는 낮음.

⇒ 따라서 사고의 사슬 프롬프트는 충분한 규모의 언어 모델에 대해, 훈련 중에 보지 못한 새로운 문제도 잘 풀 수 있다 (일반화에 용이하다)

그림 8: 사고의 연쇄를 사용하면 두 가지 상징적 추론 과제에서 더 긴 순서로 일반화하는 것이 용이해집니다.

6. Discussion

• chain-of-thought prompting : 큰 언어 모델이 여러 단계로 생각하게 만드는 간단한 방법

• 산술 추론 실험 (arithmetic reasoning) - 섹션3

  • 숫자 계산 문제에서 성능이 크게 향상됩니다.
  • 다양한 조건(다른 사람의 설명, 예시, 언어 모델)에서도 안정적인 성능

• 상식 추론(commonsense reasoning) - 섹션4

  • 언어 기반의 특성 때문에 상식적인 문제를 푸는 데도 효과적입니다.

• 기호적 추론(symbolic reasoning) - 섹션5

  • 훈련되지 않은 더 긴 문제(즉, 훈련 데이터에서 보지 못한 복잡한 문제) 푸는 데도 효과적

• 모든 실험에서 사용된 언어 모델은 추가 학습 없이, 단순히 프롬프트만 제공하여 성능을 발휘

  표준 프롬프트가 평평한 스케일링 곡선을 갖는 많은 추론 작업의 경우, 사고의 사슬 프롬프트는 스케일링 곡선을 극적으로 증가시킵니다.

• 모델의 크기가 커질수록 연쇄 사고 유도가 더 잘 작동

  • 작은 모델에서는 효과가 미미

• chain-of-thought 없이 기본 프롬프트만으로는 큰 언어 모델의 진짜 능력을 모두 보여주지 못함

• 모델 규모의 결과로 사고의 사슬 추론이 나타나는 것은 지배적인 주제였습니다 (Wei et al.,2022년 (b)) .

  사고의 사슬 프롬프트는 대규모 언어 모델이 성공적으로 수행할 수 있는 작업 집합을 확장하는 것으로 보입니다.

  다시 말해, 우리의 작업은 표준 프롬프트가 대규모 언어 모델의 기능에 대한 하한만 제공한다는 것을 강조합니다. 이 관찰은 답보다 더 많은 질문을 제기할 가능성이 높습니다.

• 제한사항

  • 우리는 먼저 사고의 사슬이 인간 추론자의 사고 과정을 모방하지만, 이것이 신경망이 실제로 "추론"하고 있는지에 대한 답은 아니라는 점을 인정합니다. 이는 우리가 열린 질문으로 남겨둡니다.
  • 둘째, 사고의 사슬로 예시를 수동으로 증강하는 비용은 few-shot 설정에서 최소이지만, 이러한 주석 비용은 미세 조정에 금지될 수 있습니다(하지만 이는 잠재적으로 합성 데이터 생성 또는 제로샷 일반화로 극복할 수 있음).
  • 셋째, 올바른 추론 경로가 보장되지 않아 정답과 오답이 모두 나올 수 있습니다. 언어 모델의 사실적 생성을 개선하는 것은 향후 작업의 열린 방향입니다 (Rashkin et al.,2021; Ye와 Durrett,2022; Wiegreffe 등,2022, 그 외 ) .
  • 마지막으로, 대규모 모델 규모에서만 생각의 사슬 추론이 등장하면서 실제 세계 애플리케이션에서 서비스하는 데 비용이 많이 듭니다. 추가 연구를 통해 더 작은 모델에서 추론을 유도하는 방법을 탐색할 수 있습니다.

7. Conclusions

• COT prompting: 언어 모델에서 추론을 강화하기 위한 간단하고 광범위한 방법
• 산술적, 상징적, 상식적 추론에 대한 실험을 통해 COT가 모델 규모의 새로운 속성이며, 이를 통해 충분히 큰 언어 모델이 그렇지 않으면 평평한 스케일링 곡선을 갖는 추론 작업을 수행할 수 있다는 것을 발견
• 언어 모델이 수행할 수 있는 추론 작업의 범위를 넓히면 언어 기반 추론 접근 방식에 대한 추가 작업에 영감을 줄 수 있기를 바랍니다.