비전·음성·추천

DOMAIN / 31번째 글

딥러닝 추천 시스템: NCF·Wide&Deep·DIN 완전 해설

Neural Collaborative Filtering·Wide&Deep·Deep Interest Network 아키텍처, 임베딩 기반 추천, 행동 시퀀스 모델링, 네거티브 샘플링과 손실 선택, PyTorch NCF 구현, 그리고 딥러닝으로 넘어갈 시점까지 해설합니다.

PALDYN Team30 MIN READ

지난 글에서 행렬 분해(SVD, ALS, FunkSVD)가 사용자-아이템 상호작용을 저차원 잠재 공간으로 압축해 추천을 만들어낸다는 것을 배웠다. 행렬 분해는 강력하지만 구조적인 한계가 있다. 사용자 벡터와 아이템 벡터가 만나는 방법이 내적 하나뿐이라는 점이다. 내적은 두 벡터의 같은 자리끼리 곱해 더하는 선형 계산이라, 「이 사용자는 액션을 좋아하지만 늦은 밤에는 잔잔한 것을 본다」 같은 조건부 취향을 담기 어렵다. 그리고 사용자 ID와 아이템 ID 말고 다른 정보 — 시간, 기기, 최근에 본 것 — 를 넣을 자리가 없다.

딥러닝 추천은 이 두 자리를 연다. 이 글은 그 출발점인 임베딩에서 시작해, 내적을 신경망으로 바꾼 NCF, 기억과 일반화를 나눠 맡긴 Wide&Deep, 행동마다 무게를 다르게 주는 DIN, 행동의 순서를 읽는 시퀀스 모델을 차례로 본다. 그리고 구조보다 결과를 더 크게 흔드는 학습 설정과, 애초에 딥러닝으로 넘어갈 때인지를 가르는 기준으로 마무리한다.

임베딩

원-핫과 임베딩

딥러닝 추천 시스템의 출발점은 임베딩(embedding)이다. 사용자 ID와 아이템 ID처럼 번호로만 구별되는 범주형 값을 수십~수백 개의 실수로 된 벡터로 바꾸는 방법이다.

가장 단순한 표현은 원-핫 인코딩이다. 사용자가 100만 명이면 100만 칸짜리 벡터를 만들고 그 사람의 자리에만 1을 둔다. 이 표현에서는 모든 사용자가 서로 똑같이 멀다 — 취향이 비슷한 두 사람이나 정반대인 두 사람이나 거리가 같다. 임베딩은 이를 64~256차원의 촘촘한 벡터로 바꾸고, 그 벡터의 값을 학습으로 정한다. 학습이 끝나면 비슷한 아이템을 고른 사용자들은 가까운 벡터를, 다른 사용자는 먼 벡터를 갖게 된다. 행렬 분해의 잠재 요인 벡터가 바로 이것이었고, 딥러닝 추천은 그 벡터를 얻는 방법을 그대로 물려받은 뒤 그 위에 층을 쌓는다.

import torch.nn as nn

# 100만 사용자를 64차원 공간으로 임베딩
user_emb = nn.Embedding(num_embeddings=1_000_000, embedding_dim=64)

# 500만 아이템을 64차원 공간으로 임베딩
item_emb = nn.Embedding(num_embeddings=5_000_000, embedding_dim=64)

nn.Embedding은 번호를 받아 표의 한 줄을 꺼내 주는 조회표다. 그 표의 값 하나하나가 학습으로 바뀌는 파라미터, 곧 모델 안에 든 숫자다.

임베딩 테이블의 메모리

이 조회표가 모델의 거의 전부다. 위 예에서 사용자 쪽이 100만 × 64 = 6,400만 개, 아이템 쪽이 500만 × 64 = 3억 2,000만 개, 합쳐 3억 8,400만 개의 숫자가 들어간다. 32비트 실수로 저장하면 약 1.5GB다. 그 위에 얹는 신경망 층은 뒤에서 볼 크기로 잡아도 수만 개에 그친다. 파라미터의 99.9퍼센트 이상이 임베딩 테이블에 있는 셈이다.

그래서 딥러닝 추천의 공학적 어려움은 신경망 계산보다 이 테이블을 어디에 두고 어떻게 갱신하느냐에 몰린다. 학습 데이터 한 묶음이 건드리는 줄은 전체 중 극히 일부라, 테이블 전체를 매번 갱신하는 대신 건드린 줄만 갱신하는 희소 갱신을 쓴다. 테이블이 GPU 한 장의 메모리를 넘으면 여러 장에 나눠 담는다.

어휘 자르기

서비스가 돌아가는 동안 ID는 계속 늘어난다. 새 사용자가 가입하고 새 상품이 등록될 때마다 표에 줄이 필요하다. 모든 ID에 줄을 주면 표가 끝없이 커지고, 한두 번 등장한 ID의 줄은 학습할 거리가 없어 무작위 값에 가깝게 남는다.

흔한 대응이 둘이다. 하나는 최소 등장 횟수를 정해 그보다 적게 나온 ID를 「기타」 한 줄로 묶는 것이다. 다른 하나는 해싱이다. ID를 해시 함수에 넣어 정해진 개수, 예컨대 200만 개의 칸 중 하나에 떨어뜨린다. 서로 다른 ID가 같은 칸을 나눠 쓰는 충돌이 생기지만, 표 크기가 고정되고 처음 보는 ID도 바로 칸을 얻는다. 충돌의 손해는 칸 수를 늘리거나 해시 함수를 둘 써서 줄인다.

NCF

딥러닝 추천 아키텍처 비교

NCF(Neural Collaborative Filtering)는 2017년 He 등이 발표한 프레임워크로, 행렬 분해를 신경망으로 일반화했다. 핵심 아이디어는 사용자와 아이템 임베딩을 내적 대신 신경망으로 결합하는 것이다.

GMF

GMF(Generalized Matrix Factorization)는 행렬 분해를 신경망 관점에서 다시 쓴 것이다. 사용자 임베딩과 아이템 임베딩을 원소별로 곱하고, 그 결과에 선형 층을 하나 통과시킨다.

# GMF: 원소별 곱으로 상호작용 모델링
u = user_emb(user_id)   # (B, D)
i = item_emb(item_id)   # (B, D)
interaction = u * i      # (B, D) 원소별 곱
score = linear(interaction)  # (B, 1)

선형 층의 가중치가 모두 1이면 원소별 곱을 그냥 더하는 것이고, 그게 바로 내적이다. GMF는 그 가중치를 학습하게 풀어 둔 것이다 — 64개 잠재 요인 중 어떤 것은 더 크게, 어떤 것은 작게 반영할 수 있다. 행렬 분해를 특수한 경우로 품는 일반화라는 이름이 여기서 나왔다.

MLP

MLP 쪽은 사용자와 아이템 임베딩을 이어 붙인 뒤 여러 겹의 완전 연결층을 통과시킨다. 각 층 뒤의 ReLU가 비선형성을 더해, 내적으로는 못 그리는 상호작용을 학습할 여지를 준다.

# MLP: 연결 후 비선형 변환
x = torch.cat([u, i], dim=-1)  # (B, 2D)
x = relu(linear1(x))            # (B, 128)
x = relu(linear2(x))            # (B, 64)
score = sigmoid(linear3(x))     # (B, 1)

최종 NCF는 GMF의 출력과 MLP의 출력을 이어 붙여 마지막 층에 넣는다. GMF가 내적에 가까운 선형 상호작용을, MLP가 비선형 상호작용을 맡아 두 관점을 함께 쓰는 구조다. 원 논문은 MovieLens와 Pinterest 데이터에서 행렬 분해보다 높은 성적을 보고했다.

실제 이득

여기에 단서가 하나 붙는다. 2020년 Rendle 등은 같은 데이터에서 행렬 분해의 하이퍼파라미터를 제대로 맞추면 내적이 NCF의 MLP 결합을 앞선다는 재검증 결과를 냈다. 이론적으로 MLP는 어떤 함수든 근사할 수 있지만, 실제로 내적이라는 단순한 함수를 MLP로 배우려면 데이터가 많이 필요하다는 것이 그 요지다. 게다가 내적은 서빙에서 결정적인 장점이 있다. 수백만 아이템 중 사용자 벡터와 내적이 큰 것을 근사 최근접 이웃 검색으로 몇 밀리초 만에 찾을 수 있지만, MLP 점수는 후보마다 신경망을 돌려야 한다.

그래서 NCF가 이기는 것은 상호작용이 정말 비선형이고 데이터가 그것을 배울 만큼 많을 때다. ID 둘만 쓰는 순수 협업 필터링이라면 잘 맞춘 행렬 분해가 여전히 강한 기준선이다. 딥러닝의 이득은 ID 바깥의 정보를 넣기 시작할 때 커진다 — 다음 절부터가 그 이야기다.

Wide & Deep

Wide&Deep은 2016년 Google이 Google Play 앱 추천을 위해 발표한 구조다. 추천에는 두 가지 상반된 능력이 필요하다는 관찰에서 출발한다.

기억과 Wide

첫째는 기억(memorization)이다. 「이 앱을 설치한 사람은 저 앱도 설치한다」처럼 과거 데이터에 자주 나타난 짝을 그대로 외워 두는 능력이다. Wide 쪽은 선형 모델이고, 입력으로 교차 특성을 받는다. 교차 특성은 두 범주형 값의 조합을 하나의 특성으로 만든 것으로, 「사용자 언어 = 한국어 AND 설치 앱 = 카카오톡」이 켜지면 1, 아니면 0인 식이다.

선형 모델은 이런 조합마다 가중치를 하나씩 따로 배운다. 데이터에 수천 번 나온 조합이라면 그 가중치는 정확하고, 결과도 설명하기 쉽다 — 「이 조합 때문에 점수가 올랐다」를 가중치 하나로 짚을 수 있다. 대신 데이터에 한 번도 안 나온 조합은 가중치가 0에 머물러 아무것도 예측하지 못한다.

일반화와 Deep

둘째는 일반화(generalization)다. 이전에 본 적 없는 조합에도 그럴듯한 예측을 내는 능력이다. Deep 쪽은 범주형 특성을 임베딩으로 바꾸고 수치 특성과 이어 붙여 신경망에 넣는다. 임베딩 공간에서 「카카오톡」과 「라인」이 가까이 있으면, 라인 사용자에게서 배운 것이 카카오톡 사용자에게도 번진다.

# Wide 파트: 선형 모델 (기억 담당)
wide_input = cross_product_features(user_feats, item_feats)
wide_out = torch.matmul(wide_input, wide_weights)

# Deep 파트: DNN (일반화 담당)
deep_input = torch.cat([user_emb, item_emb, context_feats], dim=-1)
deep_out = deep_network(deep_input)

# 두 파트 합산 후 Sigmoid
logit = wide_out + deep_out
prob = torch.sigmoid(logit)

일반화의 대가는 과잉 일반화다. 데이터가 희소한 조합에서 Deep 쪽은 「비슷해 보이는」 아이템을 지나치게 넓게 추천할 수 있다. 그 과잉을 Wide 쪽의 정확한 예외 규칙이 바로잡는다. 둘이 서로의 약점을 덮는 구조다.

함께 학습

Wide&Deep에서 두 부분은 따로 학습한 뒤 합치는 앙상블이 아니라, 출력을 더한 하나의 손실로 함께 학습한다. 그래서 Wide 쪽은 Deep 쪽이 이미 잘 맞히는 것을 다시 배울 필요가 없고, Deep이 놓치는 예외만 메우면 된다. Wide 쪽이 작은 교차 특성 몇 개로 충분한 이유다.

다만 두 쪽에 서로 다른 옵티마이저를 쓴다. 원 논문은 Wide 쪽에 L1 정규화를 건 FTRL을, Deep 쪽에 AdaGrad를 썼다. Wide 쪽의 교차 특성은 수가 엄청나고 대부분 쓸모가 없어서, L1 정규화로 쓸모없는 가중치를 정확히 0으로 만들어 모델을 가볍게 유지하려는 것이다. Deep 쪽에는 그런 희소성이 필요 없다. 이 구조는 Google Play에 실제로 배포되어 앱 설치율을 높였고, 이후 교차 특성을 사람 대신 신경망이 만드는 DeepFM·DCN 같은 변형의 출발점이 되었다.

DIN

DIN(Deep Interest Network)은 2018년 Alibaba가 광고 추천을 위해 발표한 모델이다. 기존 모델이 사용자의 과거 행동을 다루는 방식의 약점을 짚었다.

평균의 문제

Wide&Deep 같은 모델은 사용자의 과거 클릭 이력을 하나의 벡터로 만들 때 클릭한 아이템 임베딩을 평균 낸다. 이 평균은 지금 무엇을 추천하려는지와 상관없이 늘 같다. 사용자가 농구화 구매, 러닝화 조회, 요리책 구매를 했다면, 운동화 광고를 평가할 때도 요리책 광고를 평가할 때도 같은 평균 벡터를 쓴다. 운동화 광고 앞에서는 요리책이 잡음이고, 요리책 광고 앞에서는 운동화가 잡음이다. 취향이 여러 갈래인 사용자일수록 평균은 어느 갈래도 아닌 흐릿한 점이 된다.

후보 질의 어텐션

DIN은 지금 평가하는 후보 아이템을 질의로 삼아, 과거 행동마다 그 후보와 얼마나 관련 있는지 점수를 매긴다. 이렇게 입력의 각 부분에 다른 무게를 주는 장치를 어텐션(attention)이라 한다. 운동화 광고가 후보면 농구화·러닝화에 큰 무게가, 요리책에 작은 무게가 실린다.

후보 아이템에 따라 과거 행동의 무게가 달라지는 DIN 어텐션

def din_attention(query_item_emb, behavior_seq_embs):
    # query_item_emb: (B, D) - 지금 평가하는 후보 아이템
    # behavior_seq_embs: (B, T, D) - 과거 행동 시퀀스
    query_exp = query_item_emb.unsqueeze(1).expand_as(behavior_seq_embs)
    attn_input = torch.cat(
        [query_exp, behavior_seq_embs,
         query_exp - behavior_seq_embs,
         query_exp * behavior_seq_embs], dim=-1
    )
    weights = attn_net(attn_input)            # (B, T, 1) — softmax를 걸지 않는다
    return (weights * behavior_seq_embs).sum(dim=1)   # (B, D)

원 논문에서 눈여겨볼 선택이 하나 있다. 무게를 softmax로 합이 1이 되게 맞추지 않는다. 합을 1로 맞추면 관련 행동이 하나인 사용자와 열인 사용자가 같은 크기의 벡터를 얻는다. 무게를 그대로 두면 운동화 관련 행동이 많은 사용자의 관심 벡터가 더 커져, 관심의 세기까지 점수에 실린다. 이 구조는 Taobao 광고 시스템에 배포되어 클릭률을 높였고, 이후 관심의 시간 변화를 다루는 DIEN, 세션 단위로 나누는 DSIN으로 이어졌다.

긴 이력

어텐션은 후보 하나마다 과거 행동 전부를 훑으므로, 이력이 길수록 비용이 비례해 는다. 랭킹 단계에서 후보 수백 개에 각각 행동 수천 개를 훑으면 감당이 안 된다. 그래서 최근 N개, 흔히 수십에서 수백 개로 자르는 것이 기본이다.

최근 N개만 쓰면 오래된 취향이 사라진다. 1년 전 캠핑 장비를 샀던 사람에게 텐트 광고를 보여 줄 근거가 지워지는 것이다. 이를 보완하는 방법으로 후보와 같은 카테고리의 행동만 이력 전체에서 먼저 골라낸 뒤 그것에 어텐션을 거는 방식이 쓰인다. 무작위 표본을 섞는 것은 계산은 싸지만 관련 행동을 운에 맡기게 된다.

시퀀스 모델

DIN은 행동마다 무게를 달리 줬지만 행동의 순서는 보지 않았다. 사용자가 노트북을 산 직후에 노트북 가방을 찾는 것처럼, 다음 행동은 바로 앞의 행동에 크게 기댄다. 이 순서를 읽는 모델들이 뒤를 이었다.

SASRec

SASRec(Self-Attentive Sequential Recommendation, 2018)은 트랜스포머의 자기 어텐션을 추천에 가져왔다. 과거 행동 시퀀스의 각 위치가 자기보다 앞의 위치들만 보고 다음 아이템을 예측하도록 학습한다. 뒤를 못 보게 막는 이 단방향 구조는 언어 모델이 다음 낱말을 맞히는 방식과 같다.

# SASRec 핵심: 트랜스포머 인코더로 시퀀스 모델링
item_seq_embs = item_emb(item_sequence)  # (B, T, D)
item_seq_embs += pos_emb(positions)
output = transformer_encoder(item_seq_embs, causal=True)  # (B, T, D)
next_item_score = output[:, -1, :] @ candidate_embs.T

마지막 위치의 출력 벡터가 「지금 이 사용자」를 나타내고, 후보 아이템과의 내적이 점수가 된다. 학습 때는 시퀀스의 모든 위치가 각자 다음 아이템을 맞히므로, 시퀀스 하나에서 학습 신호를 T개 얻는다.

BERT4Rec

BERT4Rec(2019)은 BERT의 학습 방식을 빌렸다. 시퀀스 중간의 아이템을 무작위로 가리고, 앞뒤 양쪽을 모두 보고 가린 자리를 맞히게 한다. 양방향으로 보므로 더 풍부한 표현을 얻을 수 있다는 것이 논문의 주장이었고, 실제로 SASRec보다 높은 성적을 보고했다.

다만 이후의 재현 연구에서는 결과가 엇갈렸다. 같은 조건으로 다시 학습했을 때 BERT4Rec이 논문만큼 앞서지 못하는 경우가 보고되었고, 학습을 충분히 오래 돌려야 그 성적이 나온다는 분석도 있었다. 추천에서 「다음 행동」은 원래 한쪽 방향의 문제라, 양방향 학습이 언제나 이득인 것은 아니다. 두 모델 모두 강한 기준선이고, 자기 데이터에서 둘 다 재 보는 것이 맞다.

위치와 시간

시퀀스 모델의 위치 임베딩은 「몇 번째 행동인가」를 담는다. 그런데 추천에서 중요한 것은 종종 「얼마나 전의 행동인가」다. 5분 전 클릭과 3주 전 클릭이 바로 붙어 있으면 위치로는 이웃이지만 의미는 다르다. 그래서 행동 사이의 시간 간격을 따로 임베딩해 더하는 변형이 쓰인다.

단기 관심과 장기 취향을 함께 다루는 것도 같은 문제의 다른 얼굴이다. 오늘 세션의 몇 개 행동이 말하는 「지금 찾는 것」과 몇 달의 이력이 말하는 「원래 좋아하는 것」은 다르다. 흔한 구성은 최근 세션을 시퀀스 모델로, 긴 이력을 평균이나 DIN식 어텐션으로 따로 요약한 뒤 두 벡터를 합치는 것이다.

학습 설정

구조를 바꾸는 것보다 학습 설정을 바꾸는 것이 결과를 더 크게 흔드는 일이 흔하다. 같은 모델도 무엇을 음성 사례로 보고 무엇을 손실로 재느냐에 따라 전혀 다른 추천을 낸다.

네거티브 샘플링

추천 데이터에는 대개 긍정 사례만 있다. 클릭·구매·재생 기록은 남지만 「싫다」는 기록은 거의 없다. 그래서 사용자가 상호작용하지 않은 아이템 중 일부를 뽑아 음성 사례로 쓴다. 이것이 네거티브 샘플링이다.

PyTorch NCF 구현

import torch
import torch.nn as nn

class NCF(nn.Module):
    def __init__(self, n_users, n_items, emb_dim=64):
        super().__init__()
        self.user_emb = nn.Embedding(n_users, emb_dim)
        self.item_emb = nn.Embedding(n_items, emb_dim)
        self.mlp = nn.Sequential(
            nn.Linear(emb_dim * 2, 128), nn.ReLU(),
            nn.Linear(128, 64), nn.ReLU(),
            nn.Linear(64, 1), nn.Sigmoid()
        )

    def forward(self, user_ids, item_ids):
        u = self.user_emb(user_ids)
        i = self.item_emb(item_ids)
        return self.mlp(torch.cat([u, i], dim=-1)).squeeze(-1)

model = NCF(n_users=10000, n_items=50000, emb_dim=64)
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
criterion = nn.BCELoss()

# 긍정 사례(실제 상호작용)는 label=1, 뽑은 음성 사례는 label=0
for user_ids, item_ids, labels in dataloader:
    loss = criterion(model(user_ids, item_ids), labels.float())
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

음성 사례를 어떻게 뽑느냐가 모델의 성격을 정한다. 전체 아이템에서 균등하게 뽑으면 대부분이 아무도 안 보는 롱테일 아이템이라 맞히기가 너무 쉽다. 모델은 「인기 있는 것을 높게」만 배워도 손실이 내려간다. 인기도에 비례해 뽑으면 음성 사례에 인기 아이템이 자주 섞여, 모델이 「인기 있지만 이 사람은 안 고른 것」을 가려야 해서 더 어려운 문제를 푼다. 대신 인기 아이템을 과하게 깎아 추천 품질이 떨어질 수 있다. 둘 사이를 섞거나 인기도에 지수를 걸어 누그러뜨리는 것이 흔한 절충이고, 무엇이 나은지는 데이터가 정한다.

손실 함수

손실을 무엇으로 둘지도 고른다. 위 코드처럼 각 사용자-아이템 짝이 긍정인지 아닌지를 따로 맞히는 것이 점별(pointwise) 손실이다. 구현이 쉽지만, 추천에서 정말 중요한 것은 확률값 자체가 아니라 순서다. 쌍별(pairwise) 손실은 긍정 아이템의 점수가 음성 아이템보다 높기만 하면 되도록 학습한다 — 지난 글의 BPR이 이것이다. 목록별(listwise) 손실은 후보 목록 전체의 순서를 한꺼번에 본다. 긍정 하나와 음성 여럿을 묶어 softmax로 긍정을 고르게 하는 방식이 실무에서 많이 쓰이고, 시퀀스 모델과도 잘 맞는다.

클릭률 예측처럼 확률값 자체가 필요한 광고 시스템은 점별 손실을 쓴다. 입찰 금액에 그 확률을 곱해야 하기 때문이다. 목록의 순서만 중요하면 쌍별이나 목록별이 대개 낫다.

시간 기준 분할

평가 데이터를 무작위로 떼어 내면 미래의 정보가 학습에 새어 들어간다. 사용자가 3월에 본 것을 학습에 쓰고 1월에 본 것을 맞히게 하는 셈이다. 특히 시퀀스 모델은 이 누출에 민감해서, 무작위 분할에서는 좋던 점수가 실제 서비스에서 무너진다. 특정 날짜를 기준으로 그 이전으로 학습하고 이후로 평가하는 시간 기준 분할을 써야 서비스에서 일어날 일을 흉내 낸다.

딥러닝으로 갈 시점

행렬 분해와의 비교

비교 항목 행렬 분해 딥러닝 추천
상호작용 모델링 선형 내적 비선형 MLP·어텐션
부가 특성 활용 어려움 자연스러움
계산 비용 낮음 높음
데이터 요구량 적음 많음
해석 가능성 높음 낮음
시퀀스 모델링 불가 가능 (DIN, SASRec)

표만 보면 딥러닝이 대부분 앞서지만, 앞의 NCF 재검증에서 봤듯 ID 둘만 쓰는 문제에서는 그 차이가 생각보다 작다. 상호작용 데이터가 수천만 건에 못 미치면 잘 맞춘 행렬 분해가 오히려 더 나은 경우가 흔하다. 상호작용 수천만 건이 자주 기준선으로 언급되는 것도, 그쯤은 되어야 신경망이 내적보다 복잡한 함수를 배울 만큼 데이터가 쌓이기 때문이다.

비용과 이득

딥러닝 추천으로 옮기는 결정은 정확도 이득과 비용 증가를 나란히 놓고 내린다. 비용은 학습과 서빙 둘에서 다 는다. 학습은 GPU를 쓰고 하이퍼파라미터가 많아 맞추는 데 시간이 걸린다. 서빙에서는 앞에서 본 대로 내적 기반 검색을 못 쓰는 구조라면 후보마다 신경망을 돌려야 해서 지연이 는다.

그래서 실무 시스템은 두 단계로 나눈다. 수백만 아이템에서 수백 개를 고르는 후보 생성은 내적 기반의 가벼운 모델이 맡고, 그 수백 개의 순서를 정하는 랭킹만 무거운 딥러닝 모델이 맡는다. 랭킹 모델의 정확도가 0.5퍼센트 오르는 것이 매출로 얼마인지, 그 대가로 서빙 비용이 얼마 느는지를 같은 단위로 적어 보면 결정이 쉬워진다.

부가 특성

딥러닝이 확실하게 이기는 자리는 ID 바깥의 정보가 많을 때다. 아이템의 카테고리·가격·이미지·설명, 사용자의 기기·지역·시간대, 지금 세션에서의 행동이 그렇다. 행렬 분해에는 이런 정보를 넣을 자리가 없지만, 딥러닝 모델은 임베딩을 하나 더 만들어 이어 붙이면 된다. 신규 아이템이 상호작용 기록 없이도 카테고리와 설명만으로 추천에 들어갈 수 있는 것도 이 덕이다.

현대 산업 추천 시스템이 대부분 딥러닝 기반으로 옮겨 간 이유가 여기 있다. 다음 글에서는 수십억 아이템에서 실시간으로 추천을 내기 위해 후보 생성을 맡는 투타워(Two-Tower) 모델의 구조와 서빙 파이프라인을 살펴본다.


읽어주셔서 감사합니다. 😊

LATEST

비전·음성·추천의 최신 글

비전·음성·추천2026.09.07

오프라인 강화학습 — 쌓인 로그만으로 정책을 배우기

실제 서비스에서 탐색은 곧 사용자에게 나쁜 행동을 해 보는 일입니다. 이미 쌓인 로그만으로 정책을 배우려 할 때 왜 Q값이 혼자 부풀어 오르는지, 그 부풀음을 누르는 세 갈래 대응, 행동 복제라는 기준선의 무게, 그리고 배포 전에 성능을 재는 일이 왜 가장 어려운지를 정리합니다.

30 MIN
비전·음성·추천2026.09.07

다국어 전이 — 라벨 없는 언어에서 모델이 동작하는 이유

영어 라벨만으로 학습한 분류기가 한국어 문장을 그대로 처리하는 일이 실제로 일어납니다. 여러 언어가 한 표현 공간에 겹쳐 놓이는 원리, 그 겹침이 무너지는 조건, 번역해서 학습할지 번역해서 추론할지 고르는 기준, 그리고 언어별로 나눠 재야 하는 이유를 정리합니다.

29 MIN
비전·음성·추천2026.09.07

정보 추출 — 글 한 덩이를 표 한 줄로 바꾸는 일

계약서와 이메일을 데이터베이스에 넣으려면 글에서 값을 뽑아 칸에 채워야 합니다. 개체명·관계·사건의 세 층위, 값을 정규화하는 일이 왜 절반인지, 근거 위치를 함께 남겨야 하는 이유, 규칙·전용 모델·언어 모델의 갈림길, 그리고 필드별로 재는 평가법을 정리합니다.

31 MIN