콘텐츠 대표 이미지 - 쇼핑몰 추천 시스템 구현:협업 필터링과 AI 추천 알고리즘
🛒 쇼핑몰 개발 · AI 추천 시스템

쇼핑몰 추천 시스템 구현:
협업 필터링과 AI 추천 알고리즘

협업 필터링부터 딥러닝 기반 추천까지, 실전 코드와 함께 완전 정복 🚀

야 솔직히 말해서... 쿠팡이나 무신사 들어갔을 때 "어? 이거 내가 딱 사고 싶었던 건데?!" 하고 소름 돋은 적 있지 않음? ㅋㅋㅋ 그게 바로 추천 시스템의 마법이야. 그냥 운이 아니라 수십만 줄의 알고리즘이 너를 분석한 결과임 😎


오늘은 쇼핑몰 개발자라면 반드시 알아야 할 추천 시스템의 모든 것을 파헤쳐볼 거야. 협업 필터링(Collaborative Filtering)부터 콘텐츠 기반 필터링, 그리고 요즘 핫한 딥러닝 기반 추천까지! 이론만 떠들면 재미없으니까 실제 코드도 같이 보면서 가자고 🔥


참고로 이런 기술 지식들, 재능넷 같은 플랫폼에서 실제로 거래되는 고급 개발 스킬이기도 해. 추천 시스템 구현 능력 하나만 있어도 프리랜서로 꽤 먹고 살 수 있다는 거 알지? ㅎㅎ


추천 시스템의 전체 구조 👤 사용자 행동 데이터 📊 데이터 수집 & 전처리 🤖 추천 알고리즘 🎯 개인화 추천 결과 협업 필터링 비슷한 사용자 기반 User-Based / Item-Based 👥 Matrix Factorization 콘텐츠 기반 필터링 아이템 속성 기반 TF-IDF / 코사인 유사도 📦 Word2Vec / BERT 딥러닝 기반 신경망 추천 NCF / Transformer 🧠 Sequential Rec / GNN

🤔 추천 시스템, 도대체 뭔데?

추천 시스템(Recommendation System)은 사용자가 좋아할 만한 아이템을 자동으로 예측하고 제안하는 시스템이야. 쇼핑몰에서는 이게 매출과 직결되기 때문에 진짜 핵심 기능 중 하나임.


아마존은 전체 매출의 35%가 추천 시스템에서 나온다고 알려져 있어. 넷플릭스는 사용자가 보는 콘텐츠의 80%가 추천을 통해 발견된다고 하고. 이 숫자들 보면 왜 대기업들이 추천 알고리즘에 수백억을 쏟아붓는지 이해가 되지? ㅋㅋㅋ


추천 시스템이 해결하는 핵심 문제들

1
정보 과부하 문제
상품이 수백만 개인데 사용자가 원하는 걸 어떻게 찾음? 추천이 없으면 사용자는 그냥 나가버림 🚪
2
롱테일 상품 발굴
인기 상품만 팔리는 게 아니라, 숨어있는 니치 상품들도 적절한 사용자에게 연결해줌 💎
3
사용자 경험 개선
"어? 이거 딱 내 취향인데?" 하는 순간 → 구매 전환율 폭발 📈
4
재방문율 향상
개인화된 경험을 제공하면 사용자가 다시 돌아올 이유가 생김 🔄
"추천 시스템은 단순한 기능이 아니라, 사용자와 상품 사이의 다리를 놓는 핵심 인프라다."

추천 시스템의 입력 데이터 종류

추천 시스템이 뭘 먹고 사는지 알아야 제대로 만들 수 있어. 크게 두 가지 타입의 데이터가 있음:


데이터 타입 예시 특징
명시적 피드백
(Explicit Feedback)
별점, 리뷰, 좋아요 정확하지만 수집량이 적음 (사람들이 귀찮아서 잘 안 함 ㅋㅋ)
암묵적 피드백
(Implicit Feedback)
클릭, 구매, 체류시간, 스크롤 수집량 많지만 노이즈 존재 (실수로 클릭한 거일 수도)
사용자 프로필 나이, 성별, 지역, 관심사 콜드스타트 문제 해결에 도움
아이템 메타데이터 카테고리, 브랜드, 가격, 태그 콘텐츠 기반 필터링의 핵심 재료
컨텍스트 데이터 시간, 날씨, 디바이스, 위치 상황 인식 추천에 활용

👥 협업 필터링 (Collaborative Filtering)

협업 필터링은 추천 시스템의 클래식 중의 클래식이야. 핵심 아이디어는 엄청 단순함: "나랑 비슷한 취향의 사람이 좋아하는 걸 나도 좋아할 거야" 이거임 ㅋㅋㅋ


예를 들어 A, B, C 세 명이 있는데 A랑 B가 같은 운동화, 같은 청바지를 샀어. 그러면 B가 산 후드티를 A한테도 추천해주는 거지. 이게 협업 필터링의 본질이야.


1) 사용자 기반 협업 필터링 (User-Based CF)

알고리즘 흐름:


1
타겟 사용자와 다른 모든 사용자 간의 유사도 계산 (코사인 유사도, 피어슨 상관계수 등)
2
유사도가 높은 K명의 이웃(Neighbor) 선택
3
이웃들이 좋아했지만 타겟 사용자가 아직 보지 않은 아이템 추출
4
유사도 가중 평균으로 예측 점수 계산 후 상위 N개 추천

코사인 유사도 공식은 이렇게 생겼어:



# 코사인 유사도 계산
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

# 사용자-아이템 평점 행렬 (행: 사용자, 열: 아이템)
# 0은 평점 없음을 의미
ratings = np.array([
[5, 3, 0, 1, 0],   # 사용자 A
[4, 0, 4, 1, 2],   # 사용자 B
[1, 1, 0, 5, 4],   # 사용자 C
[0, 0, 4, 4, 0],   # 사용자 D
[2, 1, 0, 4, 5],   # 사용자 E (타겟)
])

# 사용자 간 코사인 유사도 계산
user_similarity = cosine_similarity(ratings)
print("사용자 유사도 행렬:")
print(user_similarity)

# 타겟 사용자(E, 인덱스 4)와 가장 유사한 사용자 찾기
target_user = 4
similarities = user_similarity[target_user]
# 자기 자신 제외하고 정렬
similar_users = np.argsort(similarities)[::-1][1:]
print(f"\n타겟 사용자와 유사도 순위: {similar_users}")
💡 User-Based CF의 한계: 사용자가 수백만 명이면 유사도 계산에 엄청난 연산이 필요함. 실시간 서비스에서는 오프라인으로 미리 계산해두거나 근사 알고리즘(ANN: Approximate Nearest Neighbor)을 써야 해.

2) 아이템 기반 협업 필터링 (Item-Based CF)

사용자 기반이 "나랑 비슷한 사람"을 찾는 거라면, 아이템 기반은 "내가 좋아한 상품과 비슷한 상품"을 찾는 거야. 실제로 아마존이 초기에 사용한 방식이 바로 이거임!



import pandas as pd
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

# 사용자-아이템 평점 데이터 생성
data = {
'운동화A': [5, 4, 0, 0, 2],
'운동화B': [4, 5, 0, 0, 1],
'청바지A': [0, 0, 5, 4, 0],
'청바지B': [0, 0, 4, 5, 0],
'후드티A': [3, 0, 0, 0, 5],
}
df = pd.DataFrame(data, index=['유저1','유저2','유저3','유저4','유저5'])

# 아이템 간 유사도 계산 (전치행렬 사용)
item_similarity = cosine_similarity(df.T)
item_sim_df = pd.DataFrame(
item_similarity, 
index=df.columns, 
columns=df.columns
)

print("아이템 유사도 행렬:")
print(item_sim_df.round(3))

# 특정 아이템과 가장 유사한 아이템 추천
def get_similar_items(item_name, n=3):
similar = item_sim_df[item_name].sort_values(ascending=False)
return similar[1:n+1]  # 자기 자신 제외

print("\n'운동화A'와 유사한 아이템:")
print(get_similar_items('운동화A'))

🔥 Item-Based vs User-Based 비교


구분 User-Based Item-Based
계산 대상 사용자 간 유사도 아이템 간 유사도
안정성 낮음 (사용자 취향 변함) 높음 (아이템 속성 고정)
확장성 사용자 수 증가 시 느려짐 상품 수 증가 시 느려짐
적합한 상황 사용자 수 < 아이템 수 아이템 수 < 사용자 수
실제 사용 소규모 서비스 대규모 이커머스 (아마존)

3) 행렬 분해 (Matrix Factorization) - 협업 필터링의 진화

협업 필터링의 가장 큰 문제가 뭔지 알아? 바로 희소성(Sparsity) 문제야. 쇼핑몰에 상품이 100만 개인데 한 사람이 구매한 상품은 고작 10~20개잖아. 그러면 평점 행렬의 99.99%가 비어있는 거야. 이걸 어떻게 채울 거임?


그래서 나온 게 행렬 분해(Matrix Factorization)야. 넷플릭스 프라이즈 대회(2009년)에서 우승한 알고리즘이 바로 이 방식이었어. 당시 상금이 100만 달러였는데 ㄷㄷ


핵심 아이디어: 사용자-아이템 행렬 R을 두 개의 저차원 행렬로 분해


R ≈ P × Q^T


여기서:

• R: 사용자-아이템 평점 행렬 (m × n)

• P: 사용자 잠재 요인 행렬 (m × k)

• Q: 아이템 잠재 요인 행렬 (n × k)

• k: 잠재 요인의 수 (하이퍼파라미터, 보통 20~200)


import numpy as np

class MatrixFactorization:
def __init__(self, R, k=10, lr=0.01, reg=0.01, epochs=100):
"""
R: 사용자-아이템 평점 행렬
k: 잠재 요인 수
lr: 학습률
reg: 정규화 파라미터
epochs: 학습 반복 횟수
"""
self.R = R
self.num_users, self.num_items = R.shape
self.k = k
self.lr = lr
self.reg = reg
self.epochs = epochs

def train(self):
# 사용자, 아이템 잠재 행렬 랜덤 초기화
self.P = np.random.normal(0, 0.1, (self.num_users, self.k))
self.Q = np.random.normal(0, 0.1, (self.num_items, self.k))

# 평점이 있는 위치만 학습
self.samples = [
(i, j, self.R[i, j])
for i in range(self.num_users)
for j in range(self.num_items)
if self.R[i, j] > 0
]

for epoch in range(self.epochs):
np.random.shuffle(self.samples)
self._sgd()  # 확률적 경사 하강법

if (epoch + 1) % 10 == 0:
loss = self._compute_loss()
print(f"Epoch {epoch+1}/{self.epochs}, Loss: {loss:.4f}")

def _sgd(self):
"""확률적 경사 하강법으로 P, Q 업데이트"""
for i, j, r_ij in self.samples:
# 예측값 계산
prediction = self.P[i, :].dot(self.Q[j, :].T)
error = r_ij - prediction

# 그래디언트 업데이트
self.P[i, :] += self.lr * (
error * self.Q[j, :] - self.reg * self.P[i, :]
)
self.Q[j, :] += self.lr * (
error * self.P[i, :] - self.reg * self.Q[j, :]
)

def _compute_loss(self):
"""RMSE 계산"""
predicted = self.P.dot(self.Q.T)
error = 0
for i, j, r_ij in self.samples:
error += (r_ij - predicted[i, j]) ** 2
return np.sqrt(error / len(self.samples))

def predict(self, user_id, item_id):
"""특정 사용자-아이템 쌍의 평점 예측"""
return self.P[user_id, :].dot(self.Q[item_id, :].T)

def recommend(self, user_id, n=5):
"""사용자에게 상위 N개 아이템 추천"""
user_ratings = self.R[user_id, :]
predictions = self.P[user_id, :].dot(self.Q.T)

# 이미 평점을 준 아이템 제외
unrated_items = np.where(user_ratings == 0)[0]
recommendations = [
(item_id, predictions[item_id]) 
for item_id in unrated_items
]
recommendations.sort(key=lambda x: x[1], reverse=True)
return recommendations[:n]

# 사용 예시
R = np.array([
[5, 3, 0, 1, 0],
[4, 0, 4, 1, 2],
[1, 1, 0, 5, 4],
[0, 0, 4, 4, 0],
[2, 1, 0, 4, 5],
])

mf = MatrixFactorization(R, k=3, lr=0.01, reg=0.01, epochs=100)
mf.train()
print("\n사용자 0에 대한 추천:")
print(mf.recommend(user_id=0, n=3))
💡 실무 팁: 직접 구현하기 귀찮으면 surprise 라이브러리나 implicit 라이브러리 써. 특히 implicit는 암묵적 피드백 데이터에 최적화되어 있어서 쇼핑몰에 딱임!

행렬 분해(Matrix Factorization) 개념 평점 행렬 R (사용자 × 아이템) 상품1 상품2 상품3 상품4 유저A 5 3 ? 1 유저B 4 ? 4 1 유저C 1 1 ? 5 유저D ? ? 4 4 ≈ 분해 사용자 행렬 P (사용자 × k) 요인1 요인2 유저A 0.9 0.2 유저B 0.7 0.5 유저C 0.1 0.9 유저D 0.3 0.8 × 아이템 행렬 Q^T (k × 아이템) 상품1 상품2 상품3 상품4 요인1 0.8 0.6 0.3 0.1 요인2 0.1 0.2 0.9 0.8 💡 핵심 아이디어 ? 로 표시된 빈 평점을 P × Q^T 로 예측! 잠재 요인이 "스포츠 선호도", "캐주얼 선호도" 같은 숨겨진 특성을 자동으로 학습함 → 콜드스타트 문제도 어느 정도 해결 가능!

📦 콘텐츠 기반 필터링 (Content-Based Filtering)

협업 필터링이 "다른 사람들의 행동"을 보는 거라면, 콘텐츠 기반 필터링은 "아이템 자체의 특성"을 분석해. 사용자가 빨간 운동화를 샀으면, 다른 빨간 운동화나 비슷한 스타일의 신발을 추천하는 식이지.


이 방식의 가장 큰 장점은 콜드스타트 문제에 강하다는 거야. 새로운 상품이 등록되어도 메타데이터만 있으면 바로 추천 가능! 새로운 사용자도 프로필 정보만 있으면 어느 정도 추천이 됨 👍


TF-IDF를 활용한 상품 유사도 계산

상품 설명 텍스트를 벡터화해서 유사도를 계산하는 방법이야. 쇼핑몰에서 상품 설명, 태그, 카테고리 정보를 활용하면 꽤 괜찮은 결과가 나와.



import pandas as pd
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity

# 상품 데이터 (실제로는 DB에서 가져옴)
products = pd.DataFrame({
'product_id': [1, 2, 3, 4, 5, 6],
'name': [
'나이키 에어맥스 270',
'아디다스 울트라부스트',
'뉴발란스 990v5',
'나이키 조던 1',
'아디다스 스탠스미스',
'컨버스 척테일러'
],
'description': [
'에어 쿠션 러닝화 스포츠 조깅 편안함 나이키 에어맥스',
'부스트 쿠션 러닝화 스포츠 달리기 아디다스 에너지리턴',
'클래식 러닝화 데일리 캐주얼 뉴발란스 미국산 프리미엄',
'농구화 하이탑 스트릿 패션 나이키 에어조던 레트로',
'캐주얼 스니커즈 클래식 화이트 아디다스 오리지널',
'캔버스 스니커즈 클래식 캐주얼 컨버스 올스타 데일리'
],
'category': ['러닝화', '러닝화', '러닝화', '농구화', '스니커즈', '스니커즈'],
'price': [189000, 219000, 299000, 259000, 129000, 99000]
})

# TF-IDF 벡터화
# 상품 설명 + 카테고리를 합쳐서 특성 생성
products['features'] = (
products['description'] + ' ' + 
products['category'] + ' ' + 
products['name']
)

tfidf = TfidfVectorizer(
analyzer='word',
min_df=1,
stop_words=None  # 한국어는 별도 처리 필요
)

tfidf_matrix = tfidf.fit_transform(products['features'])
print(f"TF-IDF 행렬 크기: {tfidf_matrix.shape}")
# (6개 상품, N개 단어)

# 코사인 유사도 계산
cosine_sim = cosine_similarity(tfidf_matrix, tfidf_matrix)
print("\n상품 간 코사인 유사도:")
sim_df = pd.DataFrame(
cosine_sim, 
index=products['name'], 
columns=products['name']
)
print(sim_df.round(3))

# 특정 상품과 유사한 상품 추천 함수
def content_based_recommend(product_name, n=3):
"""상품명을 입력받아 유사한 상품 N개 추천"""
idx = products[products['name'] == product_name].index[0]
sim_scores = list(enumerate(cosine_sim[idx]))
sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True)
sim_scores = sim_scores[1:n+1]  # 자기 자신 제외

product_indices = [i[0] for i in sim_scores]
result = products.iloc[product_indices][['name', 'category', 'price']].copy()
result['similarity'] = [round(i[1], 3) for i in sim_scores]
return result

print("\n'나이키 에어맥스 270'과 유사한 상품:")
print(content_based_recommend('나이키 에어맥스 270'))

Word2Vec / 임베딩 기반 상품 유사도

TF-IDF는 단어 빈도 기반이라 의미적 유사성을 잘 못 잡아. 예를 들어 "운동화"랑 "스니커즈"는 같은 의미인데 TF-IDF는 다른 단어로 취급함 ㅠㅠ


이걸 해결하는 게 Word2Vec이나 BERT 같은 임베딩 모델이야. 단어를 고차원 벡터 공간에 매핑해서 의미적으로 비슷한 단어는 벡터 공간에서도 가깝게 위치하게 만들어.



from sentence_transformers import SentenceTransformer
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

# 사전 학습된 한국어 BERT 모델 사용
# pip install sentence-transformers
model = SentenceTransformer('jhgan/ko-sroberta-multitask')

# 상품 설명 임베딩
product_descriptions = [
"에어 쿠션이 있는 러닝화, 조깅과 스포츠에 적합",
"부스트 기술이 적용된 달리기용 운동화",
"클래식한 디자인의 일상용 캐주얼 신발",
"농구 경기용 하이탑 스포츠화",
"흰색 캔버스 소재의 레트로 스타일 스니커즈",
]

# 문장 임베딩 생성 (각 설명을 768차원 벡터로 변환)
embeddings = model.encode(product_descriptions)
print(f"임베딩 차원: {embeddings.shape}")  # (5, 768)

# 코사인 유사도 계산
sim_matrix = cosine_similarity(embeddings)

# "러닝화" 관련 상품 찾기
query = "달리기할 때 신기 좋은 쿠션감 있는 신발"
query_embedding = model.encode([query])
similarities = cosine_similarity(query_embedding, embeddings)[0]

print("\n쿼리와 각 상품의 유사도:")
for i, (desc, sim) in enumerate(zip(product_descriptions, similarities)):
print(f"상품{i+1}: {sim:.3f} - {desc[:30]}...")

🎯 콘텐츠 기반 필터링의 장단점


✅ 장점:

• 새 상품/사용자에도 즉시 추천 가능 (콜드스타트 해결)

• 추천 이유를 설명하기 쉬움 ("이 상품과 비슷해서요~")

• 다른 사용자 데이터 없이도 동작


❌ 단점:

• 과도한 특화(Over-specialization): 비슷한 것만 계속 추천 → 다양성 부족

• 메타데이터 품질에 크게 의존

• 사용자의 잠재적 관심사 발굴 어려움


🧠 딥러닝 기반 추천 시스템

자 이제 진짜 핫한 영역으로 들어왔어 ㅋㅋㅋ 딥러닝 기반 추천은 기존 방법들의 한계를 극복하면서 훨씬 복잡한 패턴을 학습할 수 있어. 요즘 대형 플랫폼들이 다 이 방향으로 가고 있음.


1) Neural Collaborative Filtering (NCF)

행렬 분해의 선형적 한계를 극복하기 위해 신경망을 도입한 방법이야. 2017년 He et al.이 발표한 논문인데 지금도 많이 쓰임.



import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import numpy as np

class NCF(keras.Model):
"""Neural Collaborative Filtering 모델"""

def __init__(self, num_users, num_items, embedding_dim=32, layers_dims=[64, 32, 16]):
super(NCF, self).__init__()

# GMF (Generalized Matrix Factorization) 파트
self.gmf_user_embedding = layers.Embedding(
num_users, embedding_dim, name='gmf_user'
)
self.gmf_item_embedding = layers.Embedding(
num_items, embedding_dim, name='gmf_item'
)

# MLP (Multi-Layer Perceptron) 파트
self.mlp_user_embedding = layers.Embedding(
num_users, embedding_dim, name='mlp_user'
)
self.mlp_item_embedding = layers.Embedding(
num_items, embedding_dim, name='mlp_item'
)

# MLP 레이어들
self.mlp_layers = []
for dim in layers_dims:
self.mlp_layers.append(layers.Dense(dim, activation='relu'))
self.mlp_layers.append(layers.Dropout(0.2))

# 최종 출력 레이어
self.output_layer = layers.Dense(1, activation='sigmoid')

def call(self, inputs):
user_input, item_input = inputs

# GMF 파트: 요소별 곱
gmf_user = self.gmf_user_embedding(user_input)
gmf_item = self.gmf_item_embedding(item_input)
gmf_output = gmf_user * gmf_item  # element-wise product

# MLP 파트: 연결 후 신경망 통과
mlp_user = self.mlp_user_embedding(user_input)
mlp_item = self.mlp_item_embedding(item_input)
mlp_input = tf.concat([mlp_user, mlp_item], axis=-1)

mlp_output = mlp_input
for layer in self.mlp_layers:
mlp_output = layer(mlp_output)

# GMF + MLP 결합
combined = tf.concat([gmf_output, mlp_output], axis=-1)

# 최종 예측 (0~1 사이 값, 구매 확률)
prediction = self.output_layer(combined)
return prediction

# 모델 생성
num_users = 10000
num_items = 50000
model = NCF(num_users, num_items)

# 컴파일
model.compile(
optimizer=keras.optimizers.Adam(learning_rate=0.001),
loss='binary_crossentropy',
metrics=['accuracy', keras.metrics.AUC()]
)

# 학습 데이터 예시 (실제로는 DB에서 가져옴)
# 양성 샘플: 실제 구매한 (user, item) 쌍
# 음성 샘플: 구매하지 않은 (user, item) 쌍 (네거티브 샘플링)
train_users = np.random.randint(0, num_users, 100000)
train_items = np.random.randint(0, num_items, 100000)
train_labels = np.random.randint(0, 2, 100000).astype(float)

# 학습
history = model.fit(
[train_users, train_items],
train_labels,
batch_size=256,
epochs=10,
validation_split=0.1,
verbose=1
)

# 특정 사용자에 대한 추천
def recommend_for_user(user_id, n=10, candidate_items=None):
if candidate_items is None:
candidate_items = np.arange(num_items)

user_array = np.full(len(candidate_items), user_id)
predictions = model.predict([user_array, candidate_items], batch_size=1024)

top_indices = np.argsort(predictions.flatten())[::-1][:n]
return candidate_items[top_indices], predictions[top_indices].flatten()

items, scores = recommend_for_user(user_id=42, n=5)
print(f"사용자 42에 대한 추천 아이템: {items}")
print(f"예측 점수: {scores}")

2) 순차적 추천 (Sequential Recommendation)

사용자의 행동 순서(시퀀스)를 고려하는 추천이야. "운동화 봤다가 → 양말 봤다가 → 스포츠 바지 봤다가" 이런 패턴을 학습해서 다음에 볼 상품을 예측하는 거지. 요즘 쇼핑몰에서 "최근 본 상품 기반 추천"이 이 방식임.



import tensorflow as tf
from tensorflow.keras import layers
import numpy as np

class SASRec(tf.keras.Model):
"""Self-Attention based Sequential Recommendation"""

def __init__(self, num_items, seq_len=50, d_model=64, num_heads=2, num_blocks=2):
super(SASRec, self).__init__()
self.seq_len = seq_len
self.d_model = d_model

# 아이템 임베딩
self.item_embedding = layers.Embedding(
num_items + 1, d_model, mask_zero=True
)

# 위치 임베딩
self.pos_embedding = layers.Embedding(seq_len, d_model)

# Transformer 블록들
self.attention_layers = []
self.ffn_layers = []
self.norm_layers = []

for _ in range(num_blocks):
self.attention_layers.append(
layers.MultiHeadAttention(num_heads=num_heads, key_dim=d_model//num_heads)
)
self.ffn_layers.append(tf.keras.Sequential([
layers.Dense(d_model * 4, activation='relu'),
layers.Dense(d_model)
]))
self.norm_layers.append([
layers.LayerNormalization(),
layers.LayerNormalization()
])

self.dropout = layers.Dropout(0.2)
self.final_norm = layers.LayerNormalization()

def call(self, item_seq, training=False):
# 아이템 임베딩
seq_emb = self.item_embedding(item_seq)

# 위치 임베딩 추가
positions = tf.range(self.seq_len)
pos_emb = self.pos_embedding(positions)
x = seq_emb + pos_emb
x = self.dropout(x, training=training)

# 인과적 마스크 (미래 정보 차단)
seq_len = tf.shape(item_seq)[1]
causal_mask = tf.linalg.band_part(
tf.ones((seq_len, seq_len)), -1, 0
)

# Transformer 블록 통과
for i, (attn, ffn, norms) in enumerate(
zip(self.attention_layers, self.ffn_layers, self.norm_layers)
):
# Self-Attention
attn_out = attn(x, x, attention_mask=causal_mask, training=training)
x = norms[0](x + attn_out)

# Feed-Forward Network
ffn_out = ffn(x, training=training)
x = norms[1](x + ffn_out)

return self.final_norm(x)

# 사용 예시
num_items = 50000
seq_len = 50
model = SASRec(num_items, seq_len=seq_len)

# 사용자 행동 시퀀스 (최근 50개 상품 ID)
user_sequence = np.array([[
1234, 5678, 9012, 3456, 7890,  # 최근 구매/클릭 상품들
0, 0, 0, 0, 0,  # 패딩 (50개 맞추기)
# ... (50개까지)
]])

# 패딩 처리
padded_seq = tf.keras.preprocessing.sequence.pad_sequences(
[[1234, 5678, 9012, 3456, 7890]], 
maxlen=seq_len, 
padding='pre'
)

# 시퀀스 인코딩
output = model(padded_seq)
print(f"시퀀스 인코딩 결과 shape: {output.shape}")
# (1, 50, 64) - 각 위치에서의 사용자 상태 표현
💡 실무에서 많이 쓰는 오픈소스 추천 프레임워크: • RecBole: 70+ 추천 알고리즘 구현체, 연구/실험에 최적
• Surprise: 협업 필터링 특화, 사용하기 쉬움
• LightFM: 하이브리드 추천, 콜드스타트 강함
• implicit: 암묵적 피드백 특화, 빠른 속도
• TensorFlow Recommenders (TFRS): 구글이 만든 프레임워크

실시간 추천 시스템 아키텍처 📥 데이터 수집 레이어 클릭 로그 구매 이력 검색어 체류시간 장바구니 행동 ⚙️ 데이터 파이프라인 (Kafka + Spark Streaming) 실시간 이벤트 처리 피처 엔지니어링 데이터 정제 & 저장 🤖 추천 모델 레이어 협업 필터링 콘텐츠 기반 딥러닝 NCF 순차적 추천 앙상블 🚀 추천 서빙 레이어 (Redis Cache + API Server) 사전 계산 캐싱 실시간 재랭킹 A/B 테스트 🛒 사용자 인터페이스 (쇼핑몰 프론트엔드) 메인 추천 배너 상품 상세 유사 상품 장바구니 추천 이메일 추천

🔀 하이브리드 추천 시스템

실제 서비스에서는 하나의 알고리즘만 쓰는 경우가 거의 없어. 협업 필터링은 콜드스타트에 약하고, 콘텐츠 기반은 다양성이 부족하고... 각각의 단점이 있잖아. 그래서 여러 방법을 조합하는 하이브리드 방식을 씀!


하이브리드 방식의 종류:


1
가중 결합 (Weighted Hybrid)
각 알고리즘의 점수를 가중 평균으로 합산
예: 최종점수 = 0.6 × CF점수 + 0.4 × CBF점수
2
스위칭 (Switching)
상황에 따라 다른 알고리즘 사용
예: 신규 사용자 → 콘텐츠 기반, 기존 사용자 → 협업 필터링
3
캐스케이드 (Cascade)
한 알고리즘이 후보를 생성하고, 다른 알고리즘이 재랭킹
예: CF로 100개 후보 → 딥러닝으로 상위 10개 선택
4
피처 결합 (Feature Combination)
여러 소스의 피처를 하나의 모델에 입력
예: 사용자 임베딩 + 아이템 임베딩 + 컨텍스트 피처 → 딥러닝

class HybridRecommender:
"""협업 필터링 + 콘텐츠 기반 하이브리드 추천"""

def __init__(self, cf_model, cbf_model, cf_weight=0.6, cbf_weight=0.4):
self.cf_model = cf_model
self.cbf_model = cbf_model
self.cf_weight = cf_weight
self.cbf_weight = cbf_weight

def recommend(self, user_id, user_history, n=10):
"""
user_id: 사용자 ID
user_history: 사용자 구매/클릭 이력 (아이템 ID 리스트)
n: 추천 개수
"""
# 신규 사용자 처리 (콜드스타트)
if len(user_history) < 3:
print("신규 사용자 → 콘텐츠 기반 추천 사용")
return self._cold_start_recommend(user_history, n)

# 협업 필터링 점수
cf_scores = self.cf_model.predict_scores(user_id)

# 콘텐츠 기반 점수 (최근 본 상품 기반)
recent_items = user_history[-5:]  # 최근 5개
cbf_scores = self.cbf_model.predict_scores(recent_items)

# 점수 정규화 (0~1 범위로)
cf_scores_norm = self._normalize(cf_scores)
cbf_scores_norm = self._normalize(cbf_scores)

# 가중 결합
hybrid_scores = (
self.cf_weight * cf_scores_norm + 
self.cbf_weight * cbf_scores_norm
)

# 이미 본 상품 제외
for item_id in user_history:
hybrid_scores[item_id] = -1

# 상위 N개 반환
top_items = sorted(
enumerate(hybrid_scores), 
key=lambda x: x[1], 
reverse=True
)[:n]

return [item_id for item_id, score in top_items]

def _cold_start_recommend(self, user_history, n):
"""신규 사용자: 인기 상품 + 콘텐츠 기반"""
if not user_history:
return self._get_popular_items(n)

cbf_scores = self.cbf_model.predict_scores(user_history)
top_items = sorted(
enumerate(cbf_scores), 
key=lambda x: x[1], 
reverse=True
)[:n]
return [item_id for item_id, score in top_items]

def _normalize(self, scores):
"""Min-Max 정규화"""
import numpy as np
min_val = min(scores)
max_val = max(scores)
if max_val == min_val:
return [0.5] * len(scores)
return [(s - min_val) / (max_val - min_val) for s in scores]

def _get_popular_items(self, n):
"""인기 상품 반환 (신규 사용자용)"""
# 실제로는 DB에서 인기 상품 조회
return list(range(n))

⚡ 실전 구현: FastAPI 추천 API 서버

이론은 충분히 했으니까 이제 실제로 쇼핑몰에 붙일 수 있는 추천 API 서버를 만들어보자! FastAPI + Redis 조합으로 빠르고 확장 가능한 서버를 구축할 거야.



# main.py - FastAPI 추천 서버
from fastapi import FastAPI, HTTPException, BackgroundTasks
from pydantic import BaseModel
from typing import List, Optional
import redis
import json
import numpy as np
from datetime import datetime

app = FastAPI(title="쇼핑몰 추천 API", version="1.0.0")

# Redis 연결 (추천 결과 캐싱)
redis_client = redis.Redis(host='localhost', port=6379, db=0)
CACHE_TTL = 3600  # 1시간 캐시

# 요청/응답 모델
class RecommendRequest(BaseModel):
user_id: int
context: Optional[str] = "home"  # home, product_detail, cart, checkout
item_id: Optional[int] = None    # 상품 상세 페이지용
limit: int = 10

class RecommendItem(BaseModel):
item_id: int
score: float
reason: str  # 추천 이유 (설명 가능한 AI)

class RecommendResponse(BaseModel):
user_id: int
recommendations: List[RecommendItem]
algorithm: str
generated_at: str

# 추천 엔진 (실제로는 학습된 모델 로드)
class RecommendationEngine:
def __init__(self):
# 실제로는 저장된 모델 파일 로드
# self.model = load_model('ncf_model.h5')
# self.item_embeddings = np.load('item_embeddings.npy')
pass

def get_user_recommendations(self, user_id: int, limit: int = 10):
"""사용자 기반 추천"""
# 실제 구현에서는 학습된 모델 사용
# 여기서는 예시 데이터 반환
items = [
RecommendItem(
item_id=1001 + i,
score=round(0.95 - i * 0.05, 3),
reason="구매 이력 기반 추천"
)
for i in range(limit)
]
return items, "collaborative_filtering"

def get_similar_items(self, item_id: int, limit: int = 10):
"""유사 상품 추천"""
items = [
RecommendItem(
item_id=2001 + i,
score=round(0.90 - i * 0.04, 3),
reason=f"상품 {item_id}와 유사한 상품"
)
for i in range(limit)
]
return items, "content_based"

def get_cart_recommendations(self, user_id: int, limit: int = 5):
"""장바구니 기반 추천 (함께 구매하면 좋은 상품)"""
items = [
RecommendItem(
item_id=3001 + i,
score=round(0.85 - i * 0.06, 3),
reason="함께 구매하면 좋은 상품"
)
for i in range(limit)
]
return items, "association_rules"

engine = RecommendationEngine()

@app.post("/recommend", response_model=RecommendResponse)
async def get_recommendations(
request: RecommendRequest,
background_tasks: BackgroundTasks
):
"""메인 추천 엔드포인트"""

# 캐시 키 생성
cache_key = f"rec:{request.user_id}:{request.context}:{request.item_id}"

# 캐시 확인
cached = redis_client.get(cache_key)
if cached:
return json.loads(cached)

# 컨텍스트에 따른 추천 전략 선택
if request.context == "product_detail" and request.item_id:
items, algorithm = engine.get_similar_items(
request.item_id, request.limit
)
elif request.context == "cart":
items, algorithm = engine.get_cart_recommendations(
request.user_id, request.limit
)
else:  # home, checkout 등
items, algorithm = engine.get_user_recommendations(
request.user_id, request.limit
)

response = RecommendResponse(
user_id=request.user_id,
recommendations=items,
algorithm=algorithm,
generated_at=datetime.now().isoformat()
)

# 백그라운드에서 캐시 저장
background_tasks.add_task(
cache_recommendations,
cache_key,
response.dict(),
CACHE_TTL
)

return response

def cache_recommendations(key: str, data: dict, ttl: int):
"""추천 결과 Redis 캐싱"""
redis_client.setex(key, ttl, json.dumps(data, ensure_ascii=False))

@app.post("/feedback")
async def record_feedback(
user_id: int,
item_id: int,
action: str,  # click, purchase, skip, like
background_tasks: BackgroundTasks
):
"""사용자 피드백 수집 (모델 업데이트용)"""
feedback_data = {
"user_id": user_id,
"item_id": item_id,
"action": action,
"timestamp": datetime.now().isoformat()
}

# 피드백을 Kafka나 DB에 저장 (비동기)
background_tasks.add_task(save_feedback, feedback_data)

# 해당 사용자 캐시 무효화
pattern = f"rec:{user_id}:*"
for key in redis_client.scan_iter(pattern):
redis_client.delete(key)

return {"status": "ok", "message": "피드백 저장 완료"}

async def save_feedback(data: dict):
"""피드백 데이터 저장 (실제로는 Kafka 프로듀서 사용)"""
print(f"피드백 저장: {data}")

@app.get("/health")
async def health_check():
return {"status": "healthy", "redis": redis_client.ping()}

# 실행: uvicorn main:app --reload --port 8000

🔥 API 호출 예시 (프론트엔드에서):



// JavaScript - 메인 페이지 추천 로드
async function loadRecommendations(userId) {
const response = await fetch('/recommend', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
user_id: userId,
context: 'home',
limit: 10
})
});

const data = await response.json();

// 추천 상품 렌더링
const container = document.getElementById('recommendations');
data.recommendations.forEach(item => {
const card = createProductCard(item.item_id, item.reason);
container.appendChild(card);
});
}

// 상품 클릭 시 피드백 전송
async function onProductClick(userId, itemId) {
await fetch('/feedback', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
user_id: userId,
item_id: itemId,
action: 'click'
})
});
}

📊 추천 시스템 평가 지표

추천 시스템 만들었다고 끝이 아니야! 얼마나 잘 추천하는지 측정해야 개선이 가능하지. 추천 시스템 평가는 크게 오프라인 평가와 온라인 평가로 나뉘어.


오프라인 평가 지표


import numpy as np

def precision_at_k(recommended, relevant, k):
"""
Precision@K: 추천한 K개 중 실제 관련 있는 비율
"""
recommended_k = recommended[:k]
hits = len(set(recommended_k) & set(relevant))
return hits / k

def recall_at_k(recommended, relevant, k):
"""
Recall@K: 전체 관련 아이템 중 추천된 비율
"""
recommended_k = recommended[:k]
hits = len(set(recommended_k) & set(relevant))
return hits / len(relevant) if relevant else 0

def ndcg_at_k(recommended, relevant, k):
"""
NDCG@K: 순서를 고려한 추천 품질 (위에 있을수록 가중치 높음)
"""
recommended_k = recommended[:k]

# DCG 계산
dcg = 0
for i, item in enumerate(recommended_k):
if item in relevant:
dcg += 1 / np.log2(i + 2)  # i+2 because log2(1)=0

# IDCG 계산 (이상적인 DCG)
ideal_hits = min(len(relevant), k)
idcg = sum(1 / np.log2(i + 2) for i in range(ideal_hits))

return dcg / idcg if idcg > 0 else 0

def mean_average_precision(all_recommended, all_relevant):
"""
MAP: 여러 사용자에 대한 평균 정밀도
"""
ap_scores = []
for recommended, relevant in zip(all_recommended, all_relevant):
ap = 0
hits = 0
for i, item in enumerate(recommended):
if item in relevant:
hits += 1
ap += hits / (i + 1)
ap /= len(relevant) if relevant else 1
ap_scores.append(ap)
return np.mean(ap_scores)

# 평가 예시
recommended = [101, 203, 305, 407, 509, 611, 713, 815, 917, 1019]
relevant = {203, 509, 815, 1019, 1121}  # 실제 구매한 상품

print(f"Precision@5: {precision_at_k(recommended, relevant, 5):.3f}")
print(f"Precision@10: {precision_at_k(recommended, relevant, 10):.3f}")
print(f"Recall@5: {recall_at_k(recommended, relevant, 5):.3f}")
print(f"Recall@10: {recall_at_k(recommended, relevant, 10):.3f}")
print(f"NDCG@5: {ndcg_at_k(recommended, relevant, 5):.3f}")
print(f"NDCG@10: {ndcg_at_k(recommended, relevant, 10):.3f}")
지표 의미 언제 중요?
Precision@K 추천 K개 중 맞춘 비율 추천 정확도가 중요할 때
Recall@K 전체 정답 중 찾은 비율 놓치는 상품이 없어야 할 때
NDCG@K 순위를 고려한 품질 상위 노출 순서가 중요할 때
MAP 전체 사용자 평균 정밀도 전반적인 성능 비교
Coverage 추천된 아이템 다양성 롱테일 상품 노출 중요할 때
Novelty 새로운 아이템 추천 비율 발견 경험이 중요할 때

온라인 평가: A/B 테스트

오프라인 지표가 좋아도 실제 비즈니스 성과로 이어지지 않을 수 있어. 그래서 A/B 테스트가 필수야!


📈 A/B 테스트 핵심 지표:


• CTR (Click-Through Rate): 추천 상품 클릭률

• CVR (Conversion Rate): 추천 → 구매 전환율

• Revenue per User: 사용자당 매출

• Session Duration: 세션 체류 시간

• Bounce Rate: 이탈률


⚠️ 주의: 통계적 유의성 확보를 위해 최소 1~2주, 충분한 샘플 수(보통 수천~수만 명)가 필요해!


🥶 콜드스타트 문제 해결 전략

추천 시스템 개발자들의 영원한 숙제 ㅋㅋㅋ 콜드스타트(Cold Start)는 데이터가 없는 새로운 사용자나 새로운 상품에 대해 추천을 못 하는 문제야.


🆕 신규 사용자 콜드스타트


• 인기 상품 추천

• 온보딩 설문 (취향 수집)

• 인구통계 기반 추천

• 탐색 vs 활용 균형

📦 신규 상품 콜드스타트


• 콘텐츠 기반 유사 상품 연결

• 카테고리 인기 상품 대체

• 메타데이터 임베딩 활용

• 탐색적 노출 (Exploration)


class ColdStartHandler:
"""콜드스타트 문제 처리 전략"""

def __init__(self, popularity_model, content_model, user_threshold=5):
self.popularity_model = popularity_model  # 인기도 기반
self.content_model = content_model        # 콘텐츠 기반
self.user_threshold = user_threshold      # 이 이상 구매해야 CF 사용

def recommend(self, user_id, user_interactions, user_profile=None, n=10):
"""
상호작용 수에 따라 전략 자동 선택
"""
interaction_count = len(user_interactions)

if interaction_count == 0:
# 완전 신규: 인기 상품 + 프로필 기반
return self._new_user_recommend(user_profile, n)

elif interaction_count < self.user_threshold:
# 초기 사용자: 콘텐츠 기반 + 인기 상품 혼합
return self._early_user_recommend(
user_interactions, n, 
content_ratio=0.7
)

else:
# 충분한 데이터: 협업 필터링 사용
return self._mature_user_recommend(user_id, n)

def _new_user_recommend(self, user_profile, n):
"""완전 신규 사용자 추천"""
if user_profile:
# 나이, 성별, 관심사 기반 세그먼트 추천
segment = self._get_user_segment(user_profile)
return self.popularity_model.get_segment_popular(segment, n)
else:
# 전체 인기 상품
return self.popularity_model.get_global_popular(n)

def _early_user_recommend(self, interactions, n, content_ratio=0.7):
"""초기 사용자: 콘텐츠 기반 위주"""
content_n = int(n * content_ratio)
popular_n = n - content_n

content_recs = self.content_model.recommend(interactions, content_n)
popular_recs = self.popularity_model.get_global_popular(popular_n)

# 중복 제거 후 합치기
all_recs = content_recs + [
r for r in popular_recs if r not in content_recs
]
return all_recs[:n]

def _mature_user_recommend(self, user_id, n):
"""충분한 데이터: 협업 필터링"""
# 실제 CF 모델 호출
return [f"cf_item_{i}" for i in range(n)]

def _get_user_segment(self, profile):
"""사용자 프로필로 세그먼트 분류"""
age = profile.get('age', 25)
gender = profile.get('gender', 'unknown')

if age < 25:
return f"young_{gender}"
elif age < 40:
return f"mid_{gender}"
else:
return f"senior_{gender}"

⏱️ 실시간 vs 배치 추천 전략

추천 시스템을 운영할 때 언제 추천을 계산하느냐가 성능과 비용에 큰 영향을 미쳐. 크게 두 가지 방식이 있어:


배치 추천 (Batch Recommendation)

주기적으로(매일, 매시간) 미리 추천을 계산해두고 캐시에 저장하는 방식


✅ 장점: 빠른 응답 속도, 서버 부하 낮음, 복잡한 모델 사용 가능

❌ 단점: 실시간 행동 반영 안 됨, 저장 공간 필요


적합한 경우: 메인 페이지 추천, 이메일 추천, 주간 추천

실시간 추천 (Real-time Recommendation)

사용자의 현재 행동을 즉시 반영해서 추천을 생성하는 방식


✅ 장점: 최신 행동 즉시 반영, 개인화 수준 높음

❌ 단점: 높은 서버 부하, 복잡한 인프라 필요


적합한 경우: 상품 상세 페이지 유사 상품, 검색 결과 추천

💡 실무 베스트 프랙티스: 두 방식을 혼합해서 써! 기본 추천은 배치로 미리 계산해두고, 최근 행동(세션 내 클릭, 장바구니 추가)은 실시간으로 반영해서 재랭킹하는 방식이 가장 효율적이야.

# 배치 추천 생성 스크립트 (매일 새벽 실행)
# batch_recommend.py

import schedule
import time
import redis
import json
from datetime import datetime

redis_client = redis.Redis(host='localhost', port=6379, db=0)

def generate_batch_recommendations():
"""전체 활성 사용자에 대한 추천 사전 계산"""
print(f"[{datetime.now()}] 배치 추천 생성 시작...")

# 활성 사용자 목록 조회 (최근 30일 내 접속)
active_users = get_active_users()

# 모델 로드
model = load_recommendation_model()

batch_size = 1000
for i in range(0, len(active_users), batch_size):
batch_users = active_users[i:i+batch_size]

# 배치로 추천 생성
recommendations = model.batch_predict(batch_users, n=20)

# Redis에 저장 (24시간 TTL)
pipeline = redis_client.pipeline()
for user_id, recs in zip(batch_users, recommendations):
key = f"batch_rec:{user_id}"
pipeline.setex(key, 86400, json.dumps(recs))
pipeline.execute()

print(f"  처리 완료: {i+len(batch_users)}/{len(active_users)} 사용자")

print(f"[{datetime.now()}] 배치 추천 생성 완료!")

def get_active_users():
"""최근 30일 활성 사용자 조회"""
# 실제로는 DB 쿼리
return list(range(10000))  # 예시

def load_recommendation_model():
"""학습된 모델 로드"""
# 실제로는 저장된 모델 파일 로드
pass

# 매일 새벽 2시에 실행
schedule.every().day.at("02:00").do(generate_batch_recommendations)

if __name__ == "__main__":
generate_batch_recommendations()  # 즉시 실행
while True:
schedule.run_pending()
time.sleep(60)

🌈 다양성 확보와 필터 버블 방지

추천 시스템의 어두운 면도 알아야 해 ㅋㅋㅋ 너무 정확한 추천만 하다 보면 필터 버블(Filter Bubble) 문제가 생겨. 사용자가 항상 비슷한 상품만 보게 되어서 새로운 발견의 기회가 없어지는 거야.


🎯 다양성 확보 기법들:


1
엡실론-그리디 (ε-Greedy)
ε 확률로 랜덤 추천, (1-ε) 확률로 최적 추천
탐색(Exploration)과 활용(Exploitation)의 균형
2
MMR (Maximal Marginal Relevance)
관련성 높으면서도 이미 추천된 것과 다른 아이템 선택
다양성과 관련성의 균형
3
카테고리 다양성 강제
추천 목록에 여러 카테고리 상품이 포함되도록 제약
예: 같은 카테고리 최대 3개까지만
4
인기도 부스팅
신규 상품이나 비인기 상품에 가산점 부여
롱테일 상품 발굴 기회 제공

def mmr_rerank(candidates, query_embedding, item_embeddings, 
lambda_param=0.5, n=10):
"""
MMR (Maximal Marginal Relevance) 재랭킹
관련성과 다양성의 균형을 맞춤

lambda_param: 0이면 최대 다양성, 1이면 최대 관련성
"""
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

selected = []
remaining = candidates.copy()

while len(selected) < n and remaining:
if not selected:
# 첫 번째: 가장 관련성 높은 아이템 선택
scores = cosine_similarity(
[query_embedding], 
[item_embeddings[i] for i in remaining]
)[0]
best_idx = remaining[np.argmax(scores)]
else:
# 이후: MMR 점수로 선택
mmr_scores = []
for item in remaining:
# 쿼리와의 관련성
relevance = cosine_similarity(
[query_embedding], [item_embeddings[item]]
)[0][0]

# 이미 선택된 아이템들과의 최대 유사도
if selected:
similarities = cosine_similarity(
[item_embeddings[item]], 
[item_embeddings[s] for s in selected]
)[0]
max_sim = max(similarities)
else:
max_sim = 0

# MMR 점수: 관련성 - 다양성 패널티
mmr = lambda_param * relevance - (1 - lambda_param) * max_sim
mmr_scores.append(mmr)

best_idx = remaining[np.argmax(mmr_scores)]

selected.append(best_idx)
remaining.remove(best_idx)

return selected

def add_diversity_constraint(recommendations, item_categories, max_per_category=3):
"""카테고리 다양성 제약 추가"""
category_count = {}
diverse_recs = []

for item_id in recommendations:
category = item_categories.get(item_id, 'unknown')
count = category_count.get(category, 0)

if count < max_per_category:
diverse_recs.append(item_id)
category_count[category] = count + 1

return diverse_recs

🌟 실제 서비스 사례와 최신 트렌드

대형 플랫폼들의 추천 시스템

플랫폼 핵심 기술 특징
아마존 Item-to-Item CF + DNN "이 상품을 산 사람들이 함께 산 상품" 원조
넷플릭스 Matrix Factorization + 딥러닝 썸네일 개인화까지 추천 시스템으로 처리
유튜브 Two-Tower DNN + Transformer 수십억 개 영상 중 실시간 추천
쿠팡 하이브리드 + 실시간 재랭킹 로켓배송 가능 상품 우선 노출 결합
무신사 패션 특화 임베딩 + CF 스타일 코디 기반 추천

2024-2025 최신 트렌드

1
LLM 기반 추천 (LLM4Rec)
GPT, LLaMA 같은 대형 언어 모델을 추천에 활용. 자연어로 "여름에 입기 좋은 시원한 원피스 추천해줘" 같은 대화형 추천이 가능해짐 🔥
2
그래프 신경망 (GNN) 기반 추천
사용자-아이템 관계를 그래프로 모델링. 간접적인 연결 관계까지 학습 가능 (A가 B를 샀고, B가 C를 샀으면 A에게 C 추천)
3
멀티모달 추천
텍스트 + 이미지 + 영상을 함께 활용. 상품 이미지를 보고 비슷한 스타일 추천하는 "비주얼 서치" 기능
4
강화학습 기반 추천 (RL4Rec)
장기적인 사용자 만족도를 최적화. 단기 클릭이 아닌 장기 구매 패턴을 학습
5
프라이버시 보존 추천
연합 학습(Federated Learning)으로 개인 데이터를 서버에 올리지 않고 추천 모델 학습. GDPR 대응에 필수
"추천 시스템의 미래는 단순한 '상품 추천'을 넘어, 사용자의 라이프스타일 전체를 이해하고 큐레이션하는 방향으로 진화하고 있다."

🛠️ 개발 환경 세팅 가이드

자 이제 실제로 시작하려는 사람들을 위한 환경 세팅 가이드야. 처음 시작할 때 뭘 설치해야 하는지 헷갈리잖아 ㅋㅋㅋ



# 1. 가상환경 생성
python -m venv rec_env
source rec_env/bin/activate  # Windows: rec_env\Scripts\activate

# 2. 핵심 라이브러리 설치
pip install numpy pandas scikit-learn

# 3. 추천 시스템 특화 라이브러리
pip install surprise          # 협업 필터링
pip install implicit          # 암묵적 피드백 CF
pip install lightfm           # 하이브리드 추천

# 4. 딥러닝 프레임워크
pip install tensorflow        # 또는 torch
pip install tensorflow-recommenders  # 구글 추천 프레임워크

# 5. NLP/임베딩
pip install sentence-transformers  # BERT 기반 임베딩
pip install gensim               # Word2Vec

# 6. API 서버
pip install fastapi uvicorn
pip install redis

# 7. 데이터 처리
pip install scipy               # 희소 행렬 처리
pip install faiss-cpu           # 빠른 유사도 검색 (GPU: faiss-gpu)

# 8. 실험 관리
pip install mlflow              # 모델 버전 관리
pip install wandb               # 학습 모니터링

# requirements.txt 생성
pip freeze > requirements.txt

# 프로젝트 구조 예시
recommendation_system/
├── data/
│   ├── raw/              # 원본 데이터
│   ├── processed/        # 전처리된 데이터
│   └── embeddings/       # 사전 계산된 임베딩
├── models/
│   ├── collaborative/    # 협업 필터링 모델
│   ├── content_based/    # 콘텐츠 기반 모델
│   ├── deep_learning/    # 딥러닝 모델
│   └── hybrid/           # 하이브리드 모델
├── api/
│   ├── main.py           # FastAPI 앱
│   ├── routers/          # API 라우터
│   └── schemas/          # Pydantic 스키마
├── training/
│   ├── train_cf.py       # CF 학습 스크립트
│   ├── train_ncf.py      # NCF 학습 스크립트
│   └── evaluate.py       # 평가 스크립트
├── batch/
│   ├── batch_recommend.py  # 배치 추천 생성
│   └── feature_pipeline.py # 피처 파이프라인
├── tests/
│   └── test_recommend.py
├── docker-compose.yml    # Redis, API 서버 등
└── requirements.txt

# docker-compose.yml - 개발 환경
version: '3.8'
services:
redis:
image: redis:7-alpine
ports:
- "6379:6379"
volumes:
- redis_data:/data

api:
build: .
ports:
- "8000:8000"
environment:
- REDIS_HOST=redis
- REDIS_PORT=6379
depends_on:
- redis
volumes:
- ./models:/app/models
command: uvicorn api.main:app --host 0.0.0.0 --port 8000 --reload

jupyter:
image: jupyter/scipy-notebook
ports:
- "8888:8888"
volumes:
- ./:/home/jovyan/work

volumes:
redis_data:

🎯 마무리: 추천 시스템 개발 로드맵

와 여기까지 왔으면 진짜 대단한 거야 ㅋㅋㅋ 추천 시스템은 처음에는 복잡해 보이지만, 단계별로 접근하면 충분히 구현할 수 있어. 마지막으로 단계별 로드맵을 정리해줄게!


1
🌱 입문 단계 (1~2개월)
• 협업 필터링 기본 구현 (User-Based, Item-Based)
• surprise 라이브러리로 SVD 실습
• 기본 평가 지표 이해 (Precision@K, Recall@K)
2
🌿 중급 단계 (2~4개월)
• Matrix Factorization 직접 구현
• TF-IDF + 코사인 유사도 콘텐츠 기반 구현
• FastAPI로 추천 API 서버 구축
• Redis 캐싱 적용
3
🌳 고급 단계 (4~8개월)
• NCF, SASRec 등 딥러닝 모델 구현
• 하이브리드 추천 시스템 설계
• A/B 테스트 프레임워크 구축
• 실시간 추천 파이프라인 구축
4
🚀 전문가 단계 (8개월+)
• LLM 기반 대화형 추천
• GNN 기반 추천 시스템
• 강화학습 적용
• 대규모 분산 시스템 설계
💡 마지막 꿀팁: 처음부터 완벽한 시스템을 만들려고 하지 마! 일단 간단한 인기 상품 추천부터 시작해서 → 협업 필터링 → 딥러닝 순서로 점진적으로 개선해나가는 게 실무에서 훨씬 현실적이야. 그리고 재능넷에서 추천 시스템 관련 프로젝트를 찾아보면 실제 케이스를 접할 수 있으니 참고해봐! 🙌
"완벽한 추천 시스템은 없다. 지속적인 실험과 개선만이 있을 뿐이다. 오늘 배운 것을 바로 코드로 옮겨보는 것이 최고의 학습법이다."

추천 시스템은 데이터 사이언스, 머신러닝, 백엔드 개발, 인프라 엔지니어링이 모두 결합된 종합 예술이야. 어렵지만 그만큼 배울 게 많고, 실제 비즈니스 임팩트도 엄청나게 크지. 이 글이 너의 추천 시스템 개발 여정에 도움이 됐으면 좋겠어! 화이팅 🔥

댓글 작성

이 글에 대한 여러분의 생각을 들려주세요

댓글 0
댓글을 불러오는 중입니다.

아직 댓글이 없습니다.