jaegwon-lee.log

[프로젝트] GraphSAGE 기반 음악 추천 시스템

Thu, 17 Apr 2025 03:14:29 GMT

음악 추천 서비스 Au-Dionysos에 사용된 GraphSAGE 구현 코드 리뷰

음악 추천 서비스 Au-Dionysos [Velog]
Au-Dionysos 서비스 코드 [GitHub]

폴더 구조

📦models ┣ 📂EDA ┣ 📂graphsage_cbf ┃ ┣ 📜args_cbf.py ┃ ┣ 📜args_tag.py ┃ ┣ 📜data_preprocessing.py ┃ ┣ 📜model.py ┃ ┣ 📜trainer.py ┃ ┗ 📜utils.py ┣ 📂graphsage_cf ┃ ┣ 📜args.py ┃ ┣ 📜data_preprocessing.py ┃ ┣ 📜model.py ┃ ┣ 📜trainer.py ┃ ┗ 📜utils.py ┣ 📜content_based_model.py ┣ 📜filtering.py ┣ 📜inference.py ┣ 📜inference_cbf_model.py ┣ 📜inference_cf_model.py ┣ 📜inference_tag_model.py ┣ 📜make_data.py ┣ 📜tag_embedding.py ┣ 📜train_cbf_model.py ┣ 📜train_cf_model.py ┣ 📜train_graphsage.sh ┗ 📜train_tag_model.py

GraphSAGE - CF Model

train_cf_model.py

1. 모듈 불러오기

import torch
import warnings
from torch.nn import TripletMarginLoss
from torch_geometric import EdgeIndex
from torch_geometric.loader import LinkNeighborLoader

from graphsage_cf.args import parse_args
from graphsage_cf.data_preprocessing import data_preprocessing
from graphsage_cf.model import Model
from graphsage_cf.trainer import train, test, feature
from graphsage_cf.utils import set_seed, makedirs, get_logger

PyTorch
Warning 메시지 무시
Triplet Loss 함수
그래프 생성
graphsage_cf 폴더의 모듈

2. 설정

def main():
    args = parse_args()
    set_seed(args.seed)
    makedirs(args.log_dir)
    makedirs(args.model_dir)
    logger = get_logger(filename=f'{args.log_dir}{args.model_name}.log')
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    warnings.filterwarnings('ignore')

argument 불러오기
Seed 설정
파일 경로/이름 지정
GPU 설정
Warning 메시지 무시

3. 데이터 전처리

    # 데이터 전처리
    train_data, valid_data, test_data, train_edge_index, valid_edge_index, test_edge_index = data_preprocessing(args)

4. Edge

    # Edge 저장
    sparse_size = (train_data['user'].num_nodes, train_data['track'].num_nodes)
    train_edge_index = EdgeIndex(
        train_edge_index.to(device),
        sparse_size=sparse_size,
    ).sort_by('row')[0]
    valid_edge_index = EdgeIndex(
        valid_edge_index.to(device),
        sparse_size=sparse_size,
    ).sort_by('row')[0]
    test_edge_index = EdgeIndex(
        test_edge_index.to(device),
        sparse_size=sparse_size,
    ).sort_by('row')[0]

5. DataLoader

    # DataLoader
    train_loader = LinkNeighborLoader(
        train_data,
        num_neighbors = {('user', 'listen', 'track'): [args.neighbors_sampling] * args.n_layers,    # [node 당 sample 개수] * layer 개수
                         ('tag', 'tagged', 'track'): [args.neighbors_sampling] * args.n_layers,
                         ('track', 'rev_listen', 'user'): [args.neighbors_sampling] * args.n_layers,
                         ('track', 'rev_tagged', 'tag'): [args.neighbors_sampling] * args.n_layers},
        edge_label_index = (('user', 'listen', 'track'), train_data['user', 'listen', 'track'].edge_index),
        batch_size = args.batch_size,
        shuffle = True,
        filter_per_worker=True,
    )

6. 모델 정의

    # 모델 정의
    model = Model(data=train_data, x_dim=args.x_dim, embedding_dim=args.embedding_dim, hidden_dim=args.hidden_dim, n_layers=args.n_layers).to(device)
    optimizer = torch.optim.Adam(model.parameters(), lr=args.learning_rate)
    loss = TripletMarginLoss(margin=args.margin).to(device)

7. Train / Validation

    counter = 0
    best_interaction_dict = {'epoch':0, 'train_loss':0, 'train_ndcg':0, 'train_recall':0, 'valid_ndcg':0, 'valid_recall':0}
    for epoch in range(1, args.epochs+1):
        print(f'Epoch: {epoch:02d}')
        # train
        train_ndcg, train_recall, train_loss = train(args, model=model, optimizer=optimizer, loss=loss,
                                                     dataloader=train_loader, data=train_data, train_edge_index=train_edge_index,
                                                     k=args.topk, device=device)
        logger.info(f'Epoch: {epoch:02d}  Loss: {train_loss:.4f}')
        logger.info(f'Train Interaction NDCG@{args.topk}: {train_ndcg:.4f}  Train Interaction Recall@{args.topk}: {train_recall:.4f}')

        # validation
        valid_ndcg, valid_recall = test(model=model, data=valid_data, k=args.topk, device=device,
                                        train_edge_index=train_edge_index, test_edge_index=valid_edge_index)
        logger.info(f'Valid Interaction NDCG@{args.topk}: {valid_ndcg:.4f}  Valid Interaction Recall@{args.topk}: {valid_recall:.4f}')

        # Best Interaction 모델 저장
        if valid_ndcg > best_interaction_dict['valid_ndcg']:
            logger.info(f'Best Interaction NDCG@{args.topk} is Updated')
            best_interaction_dict = {'epoch': epoch, 'train_loss': train_loss, 'train_ndcg': train_ndcg, 'train_recall': train_recall, 'valid_ndcg': valid_ndcg, 'valid_recall': valid_recall}
            torch.save(model.state_dict(), f'{args.model_dir}{args.model_name}.pt')    # interaction 모델 저장
            counter = 0
        else:
            counter += 1

        # early stopping (최소 epoch 이상이면서 지정된 횟수의 epoch 동안 성능 향상 없을 때)
        if (epoch > args.min_epochs) and (counter >= args.early_stopping):
            logger.info(f'Early Stopping at Epoch {epoch:02d}')
            break

8. Feature 모델 평가

    # Feature 모델 결과 출력
    feature_ndcg_dict, feature_recall_dict = feature(data=test_data, k=args.topk, device=device,
                                                     train_edge_index=train_edge_index, valid_edge_index=valid_edge_index, test_edge_index=test_edge_index)
    logger.info('Feature Model')
    logger.info(f'Train Feature NDCG@{args.topk}: {feature_ndcg_dict["train"]:.4f}  Train Feature Recall@{args.topk}: {feature_recall_dict["train"]:.4f}')
    logger.info(f'Valid Feature NDCG@{args.topk}: {feature_ndcg_dict["valid"]:.4f}  Valid Feature Recall@{args.topk}: {feature_recall_dict["valid"]:.4f}')
    logger.info(f'Test  Feature NDCG@{args.topk}: {feature_ndcg_dict["test"]:.4f}  Test  Feature Recall@{args.topk}: {feature_recall_dict["test"]:.4f}')

    # Best 모델 결과 출력
    logger.info('Best Interaction Model')
    logger.info(f'Epoch: {best_interaction_dict["epoch"]:02d}  Loss: {best_interaction_dict["train_loss"]:.4f}')
    logger.info(f'Train Interaction NDCG@{args.topk}: {best_interaction_dict["train_ndcg"]:.4f}  Train Interaction Recall@{args.topk}: {best_interaction_dict["train_recall"]:.4f}')
    logger.info(f'Valid Interaction NDCG@{args.topk}: {best_interaction_dict["valid_ndcg"]:.4f}  Valid Interaction Recall@{args.topk}: {best_interaction_dict["valid_recall"]:.4f}')

9. Test

    # test
    model = Model(data=train_data, x_dim=args.x_dim, embedding_dim=args.embedding_dim, hidden_dim=args.hidden_dim, n_layers=args.n_layers).to(device)
    model.load_state_dict(torch.load(f'{args.model_dir}{args.model_name}.pt'))    # Best 모델 로드
    test_ndcg, test_recall = test(model=model, data=test_data, k=args.topk, device=device,
                                  train_edge_index=train_edge_index, test_edge_index=test_edge_index)
    logger.info(f'Test  Interaction NDCG@{args.topk}: {test_ndcg:.4f}   Test  Interaction Recall@{args.topk}: {test_recall:.4f}')


if __name__ == '__main__':
    main()

[논문] TokenRec: Learning to Tokenize ID for LLM-based Generative Recommendations

Fri, 11 Apr 2025 09:22:00 GMT

📄 Paper

TokenRec: Learning to Tokenize ID for LLM-based Generative Recommendations [arxiv]

Haohao Qu IEEE TKDE 2024

📝 3줄 요약

TokenRec은 LLM을 추천 시스템에 맞게 조정하기 위해 사용자 및 아이템 ID를 효과적으로 토큰화하는 Masked Vector-Quantized Tokenizer를 도입한다.
Masked Vector-Quantized Tokenizer는 고차원 협업 지식을 포함시켜 자연어와 자연스럽게 통합될 수 있도록 설계되었다.
생성적 검색 패러다임을 도입하여 효율적으로 사용자 선호도를 모델링하고 최적의 아이템을 추천하는 방식으로 기존 LLM 기반 시스템보다 빠르고 효과적으로 작동한다.

Abstract

배경

LLM과 추천 시스템의 원활한 연동을 보장하기 위해 사용자 및 아이템을 토큰화하는 것은 필수적이다.
기존 연구들은 텍스트 콘텐츠 또는 잠재적 표현을 사용하여 사용자 및 아이템을 표현하는 데 진전을 이루었지만, LLM과 호환되는 이산 토큰으로 고차원 협업 지식을 포착하고 unseen 사용자/아이템을 일반화하는 데 어려움이 남아 있다.

제안 방법 : TokenRec

TokenRec은 LLM 기반 추천을 위한 효과적인 ID 토큰화 전략과 효율적인 검색 패러다임을 도입하는 새로운 프레임워크다.
토큰화 전략 : 협업 필터링에서 학습되고 마스크된 사용자/아이템 표현을 이산 토큰으로 양자화하여 고차원 협업 지식의 원활한 통합과 LLM 기반 RecSys를 위한 사용자 및 아이템의 일반화 가능한 토큰화를 달성한다.
생성적 검색 패러다임 : 사용자를 위한 상위 K개 아이템을 효율적으로 추천하도록 설계되어 LLM에서 사용되는 시간 소모적인 자기 회귀 디코딩 및 빔 검색 프로세스의 필요성을 없애므로 추론 시간을 크게 줄인다.

실험 및 결과

광범위한 실험을 통해 제안 방법의 효과를 검증했다.
TokenRec이 기존 추천 시스템과 새롭게 떠오르는 LLM 기반 추천 시스템을 포함한 경쟁력 있는 벤치마크보다 성능이 우수함을 입증했다.

결론

TokenRec은 LLM 기반 추천 시스템의 성능 향상과 효율성 증대에 기여할 수 있다.

Figure

TokenRec 프레임워크

Vector Database : GNN 모델을 통해 사용자-아이템 상호작용 그래프를 학습하여 사용자와 아이템 표현을 생성한다.
Masked Vector-Quantized Tokenizer : 아이템 ID 토큰화를 위해 K-way 인코더와 K-to-1 Decoder를 사용한다.
Generative Retrieval for Recommendations : MQ-Tokenizer를 통해 토큰화된 사용자와 아이템 ID를 LLM에 입력하여 추천을 위한 생성적 검색을 수행한다.

LLM 기반 추천 시스템에서 ID 토큰화 방법 비교

기존 방법과는 달리, 제안하는 접근 방식은 고차원 협업 지식을 활용하여 LLM과 호환되는 토큰으로 사용자와 아이템을 토큰화할 수 있다.

1. Introduction

배경

사용자 선호도에 부합하는 개인화된 추천을 제공하기 위해 가장 대표적인 기술 중 하나는 사용자-아이템 상호 작용 이력을 모델링하여 협업 지식을 포착하는 것을 목표로 하는 협업 필터링(CF)이다.
- 행렬 분해(MF)는 사용자-아이템 행렬을 두 개의 저랭크 행렬로 분해하여 사용자 행동을 예측하고 추천을 생성한다.
- 그래프 신경망(GNN)은 사용자-아이템 상호 작용 그래프에서 고차원 협업 지식을 포착하여 ID 방식으로 추천을 크게 향상시킨다.
- 기존 방법의 주요 아이디어는 이산적인 사용자 및 아이템 ID(토큰)에 대해 학습 가능한 표현(토큰 임베딩)을 얻는 것이다.
ID 기반 추천 방법과 달리 사용자 및 아이템 토큰화는 추천 내에서 LLM을 활용하는 데 있어 가장 중요한 단계 중 하나이다.
LLM 기반 추천 시스템을 위한 사용자 및 아이템 토큰화에 대한 기존 방법의 대부분은 여전히 몇 가지 제한 사항이 있다.
- 전체 단어 임베딩을 사용하면 고차원 협업 지식을 효과적으로 포착할 수 없고, 추천을 위해 unseen 사용자/아이템을 잘 일반화할 수 없다.
- 언어 모델에서 이산 토큰의 특성으로 인해 연속 인덱싱을 사용하면 추천 시스템에서 LLM을 긴밀하게 연동하기가 어렵다.

제안 방법 : TokenRec

고차원 협업 지식을 LLM에 원활하게 통합하여 사용자 및 아이템의 숫자 ID(식별자)를 토큰화하는 새로운 토큰화 전략이 제안된다.
생성적 검색 패러다임은 아이템 표현을 생성하고 협업 추천을 위해 적절한 아이템을 검색하도록 개발되었다.

주요 기여

LLM에 맞게 조정된 사용자 및 아이템을 토큰화하기 위해 마스크된 벡터 양자화 토크나이저라는 주요 전략을 도입하여 LLM 기반 추천에서 고차원 협업 지식을 통합하는 데 기여한다. 제안하는 토큰화 방법의 일반화 능력을 LLM 기반 추천에서 향상시키기 위해 두 가지 새로운 메커니즘(마스킹 및 K-way 인코더)이 설계되었다.
LLM 시대에 추천 시스템을 위한 새로운 프레임워크(TokenRec)를 제안한다. 생성적 검색 패러다임은 자연어로 토큰을 직접 생성하는 대신 사용자를 위해 상위 K개 아이템을 효과적이고 효율적으로 추천하도록 설계되었다.
널리 사용되는 4개의 실제 데이터 세트에 대한 광범위한 실험을 수행하여 제안하는 TokenRec의 효과를 경험적으로 입증한다. 뛰어난 추천 성능과 새로운 사용자 및 보지 못한 사용자의 선호도를 예측하는 일반화 능력이 포함된다.

2. The Proposed Method

2.1 Notations and Definitions

사용자 집합 $U = {u_1, u_2, ..., u_n}$ 아이템 집합 $V = {v_1, v_2, ..., v_m}$

사용자 $u_i$가 과거에 상호작용한 아이템 집합은 $N(u_i)$로 표기한다. 전통적인 협업 필터링과 마찬가지로, 사용자는 임베딩 벡터 $p_i \in \mathbb{R}^d$, 아이템은 $q_j \in \mathbb{R}^d$로 표현된다. 여기서 $d$는 잠재 벡터의 차원 수이다.

추천 시스템의 목표는 사용자 $U$와 아이템 $V$ 사이의 상호작용(e.g. 클릭, 구매 등)을 기반으로 사용자의 선호도를 학습하는 것이다. 이를 위해 협업 필터링(CF) 기법은 사용자와 아이템의 표현을 과거 상호작용으로부터 학습한다.

TokenRec은 이 협업 필터링 문제를 LLM의 관점에서 재정의한다. 사용자 $u_i$와 아이템 $v_j$를 각각 토큰 ID $T_i$, $T_j$로 변환하고, 이를 텍스트 프롬프트 $P$에 통합하여 LLM에 입력한다. LLM은 다음과 같이 사용자 $u_i$가 선호할 가능성이 있는 아이템의 표현 $z_i$를 생성한다. $$ z_i = \text{LLM}(P, T_i, {T_j \mid v_j \in N(u_i)}) $$ 이때 상호작용한 아이템 집합 $N(u_i)$는 시퀀스가 아닌 비순차적인 방식으로 입력된다. 이는 협업 필터링 설정을 반영하기 위함이다.

2.2 An Overview of the Proposed Framework

TokenRec은 자연어와 추천 과제 간의 정렬을 강화하기 위한 LLM 기반 생성 추천 프레임워크이다. 전체 프레임워크는 두 가지 주요 모듈로 구성된다.

Masked Vector-Quantized Tokenizer (MQ-Tokenizer)
Generative Retrieval for Recommendations

MQ-Tokenizer for Users and Items

사용자와 아이템의 숫자 ID를 자연어 형태로 변환하는 ID 토크나이징 문제를 해결하는 것을 목표로 한다. 추천 시스템에서는 사용자와 아이템의 수가 매우 많기 때문에, 이를 효과적으로 토크나이즈하는 것이 핵심 과제이다.

이를 해결하기 위해 MQ-Tokenizer는 다음을 수행한다:

특정 코드북(codebook)을 학습
사용자와 아이템을 특수 토큰 목록으로 표현
인코더–디코더 네트워크를 통해 벡터 양자화 수행

이 구조는 수많은 사용자 및 아이템 ID를 LLM에 자연스럽게 통합할 수 있도록 설계되었다.

Generative Retrieval for Recommendations

사용자의 개인화를 위해 LLM을 이용해 사용자 모델링을 수행한다. 이 과정에서 생성 기반 검색(generative retrieval)을 통해 전체 아이템 집합에서 사용자가 선호할 만한 $K$개의 아이템을 효율적으로 추출하고, 개인화된 Top-K 추천 리스트를 생성한다.

이 두 모듈을 통해 TokenRec은 추천 시스템과 자연어 처리 모델 간의 간극을 효과적으로 메워주며, 강력한 추천 성능을 보장한다.

2.3 Masked Vector-Quantized Tokenizers for Users and Items

기존 방식처럼 각 사용자와 아이템에 대해 고유한 토큰을 할당할 경우, 어휘 집합의 크기가 급격히 증가하게 된다. 이를 해결하기 위해 본 논문에서는 사용자와 아이템을 자연어와 정렬된 형태로 토크나이즈하는 새로운 전략을 제안한다. 핵심 아이디어는 벡터 양자화(Vector Quantization, VQ) 기술을 활용하여, 사용자 및 아이템을 일정한 이산 토큰(discrete tokens)으로 표현하는 것이다.

1) Collaborative Knowledge

고차 협업 지식(high-order collaborative knowledge)을 표현에 반영하기 위해, GNN 기반의 추천 모델로부터 학습된 임베딩을 양자화 대상으로 활용한다. GNN은 사용자와 아이템 간의 협업 신호를 포착하는 데 강점을 가지므로, 여기서 생성된 표현은 협업 지식을 잘 반영한다고 볼 수 있다. 이 임베딩을 양자화하여 사용함으로써, 유사한 사용자 및 아이템은 자연스럽게 유사한 토큰을 공유하게 되어 LLM 기반의 자연어 표현과의 정렬을 가능하게 한다.

2) Masking Operation

일반화 능력을 향상시키기 위해, 입력 임베딩에 대해 마스킹 연산을 수행한다. 이는 임베딩 벡터의 일부 요소를 확률적으로 제거함으로써 모델이 다양한 샘플을 학습하도록 유도한다. 마스킹은 Bernoulli 분포에 따라 적용되며 다음과 같이 표현된다. $$ \epsilon \sim Bernoulli(\rho) $$ $$ p'_i = Mask(p_i, \epsilon), \quad q'_j = Mask(q_j, \epsilon) $$ 여기서 $\rho$는 마스킹 비율이며, $p'_i$, $q'_j$는 마스킹된 사용자와 아이템 표현이다. 마스킹은 학습 에폭마다 달라지며, 다양한 훈련 샘플을 생성하여 일반화를 도모한다.

3) K-way Encoder and Codebook

마스킹된 임베딩을 입력으로, K-way 인코더는 서로 다른 K개의 인코더로 구성된다. 각 인코더는 마스킹된 입력을 받아 독립적인 잠재 벡터를 생성한다. $$ a^k_j = Enc^k(q'_j) = MLP^k(q'_j) $$ 각 $a^k_j \in \mathbb{R}^{d_c}$는 $k$번째 인코더의 출력이며, $MLP^k$는 3-layer 다층 퍼셉트론이다.

생성된 벡터는 K개의 코드북 중 하나의 코드워드(codeword)와 매칭된다. 이 때 유클리드 거리 기반의 최근접 이웃 탐색을 사용한다. $$ w^k_j = \arg\min_l |a^k_j - c^k_l|^2 $$ $$ Quantize(a^k_j) = c^k_{w^k_j} $$ 이를 통해 아이템 $v_j$는 다음과 같이 K개의 이산 토큰으로 표현된다. $$ v_j \rightarrow \text{tokens: } {w^1_j, w^2_j, ..., w^K_j} \rightarrow \text{tokens' embeddings: } {c^1_{w^1_j}, c^2_{w^2_j}, ..., c^K_{w^K_j} } $$

4) K-to-1 Decoder

양자화된 K개의 토큰 임베딩을 평균 풀링한 후, 3-layer MLP를 이용해 원래 입력 임베딩을 재구성한다.

$$ r_j = Dec({w^1_j, ..., w^K_j}) = MLP\left( \frac{1}{K} \sum_{k=1}^K c^k_{w^k_j} \right) $$

5) Learning Objective

MQ-Tokenizer 학습을 위한 손실 함수는 총 세 가지로 구성된다.

Reconstruction Loss
원래의 GNN 기반 임베딩 $q_j$와 재구성된 임베딩 $r_j$의 차이를 최소화한다. $$ \mathcal{L}^{Item}_{recon} = |q_j - r_j|^2 $$
Codebook Loss
선택된 토큰 임베딩이 인코더 출력에 가까워지도록 유도한다. $$ \mathcal{L}^{Item}{cb} = \sum{k=1}^K | \text{sg}[Enc^k(q'j)] - c^k{w^k_j} |^2 $$
Commitment Loss
인코더 출력이 토큰 임베딩에 지나치게 흔들리지 않도록 제어한다. $$ \mathcal{L}^{Item}{cm} = \sum{k=1}^K | Enc^k(q'j) - \text{sg}[c^k{w^k_j}] |^2 $$

최종적으로, 아이템 MQ-Tokenizer의 총 손실 함수는 다음과 같이 정의된다. $$ \mathcal{L}^{Item}{MQ} = \mathcal{L}^{Item}{recon} + \mathcal{L}^{Item}{cb} + \beta^{Item} \cdot \mathcal{L}^{Item}{cm} $$ 사용자 MQ-Tokenizer 또한 유사한 방식으로 정의되며, 총 손실은 다음과 같다. $$ \mathcal{L}^{User}{MQ} = \mathcal{L}^{User}{recon} + \mathcal{L}^{User}{cb} + \beta^{User} \cdot \mathcal{L}^{User}{cm} $$ 여기서 $\beta^{Item}$, $\beta^{User}$는 각 손실 항의 중요도를 조절하는 하이퍼파라미터이다.

2.4 Generative Retrieval for Recommendations

LLM을 추천 시스템에 효과적으로 활용하는 새로운 프레임워크를 소개한다. 핵심은 Generative Retrieval Paradigm으로, 사용자와 아이템 표현을 생성하고 이를 통해 협업 필터링 기반의 추천을 수행하는 방식이다.

1) Tokenization & Prompts

사용자·아이템 ID의 효율적인 토크나이징

일반적인 LLM은 수천~수만 개의 토큰만을 지원하지만, 실제 추천 시스템에서는 수백만에서 수십억 개의 사용자 및 아이템을 다루어야 한다. 이를 해결하기 위해 MQ-Tokenizer를 도입한다.

사용자와 아이템 ID는 각각 $K$개의 서브코드북(Sub-codebook)으로 분해되고, 각 서브코드북에서는 $L$개의 OOV(out-of-vocabulary) 토큰이 사용된다.
예를 들어, $K=3$, $L=512$일 때 총 $3 \times 512 = 1536$개의 토큰만으로도 39,387개의 아이템을 표현할 수 있다. (실험을 통해 증명)
일반적인 텍스트는 LLM의 기존 토크나이저(SentencePiece 등)를 사용하고, 사용자/아이템 ID는 MQ-Tokenizer를 통해 처리한다.

프롬프트 설계

LLM의 성능을 높이기 위해, 명시적인 프롬프트를 설계하여 모델이 사용자 선호를 이해하도록 유도한다.

이러한 프롬프트에서 ⟨uk-·⟩ 및 ⟨vk-·⟩ 형태의 토큰은 각각 사용자와 아이템 ID를 나타내는 OOV 토큰이다.

2) User Modeling via LLM

입력 구성

사용자 모델링의 목표는 사용자의 선호를 포착하고, 다음에 추천할 아이템의 표현을 생성하는 것이다. 입력은 다음과 같이 구성한다. $$ X_i = (P, T^c_{u_i}) \quad \text{or} \quad (P, T^c_{u_i}, {T^c_{v_j} \mid v_j \in N(u_i)}) $$

$T^c_{u_i}$ : 사용자 $u_i$의 MQ-Tokenizer 기반 토큰
$N(u_i)$ : 사용자 $u_i$가 상호작용한 아이템들의 집합
${T^c_{v_j}}$ : 상호작용 아이템들의 MQ-Tokenizer 기반 토큰

이때, 시퀀스 정보는 무시하고 $N(u_i)$ 내 아이템들은 무작위 순서로 배치한다.

사용자 표현 생성

기존 방식은 텍스트 생성을 통해 추천 결과를 출력하지만, 본 방식에서는 사용자 표현을 직접 생성한다.

기존의 auto-regressive 방식은 다음과 같다. $$ T_t = \text{LLM}(X_i, T_{1:t-1}) $$ 그러나 본 연구에서는 다음과 같이 사용자 표현을 추출한다. $$ h_i = \text{LLM4Rec}(X_i) $$ 이 표현 $h_i$는 사용자 $u_i$의 다음 아이템에 대한 생성적 선호를 나타낸다.

3) Generative Retrieval

기존 방식의 한계

자연어 생성 방식은 다음과 같은 문제를 가진다.

속도 저하 : beam search 필요
환각 문제 : 존재하지 않는 상품명 생성 가능
신규 아이템 대응 불가 : fine-tuning 시 학습하지 않은 아이템은 추천 불가

제안 방식 : 생성 기반 검색

위 문제를 해결하기 위해, 생성 기반 검색 방식을 제안한다. LLM으로부터 얻은 표현 $h_i$를 잠재 표현 공간으로 투영하여 검색 기반 추천을 수행한다. $$ z_i = \text{Proj}(h_i) $$ 여기서 $\text{Proj}(\cdot)$는 3-layer MLP로 구성된 projection layer이다. $z_i$는 사용자 $u_i$의 다음 아이템에 대한 잠재 표현(latent representation)이다.

유사도 기반 아이템 검색

추천은 다음과 같이 cosine similarity를 이용하여 수행한다. $$ y_{ij} = \frac{z_i \cdot q_j}{|z_i| , |q_j|} $$

$q_j$ : 아이템 $v_j$의 GNN 기반 표현
$y_{ij}$ : 사용자 $u_i$가 아이템 $v_j$를 선호할 확률 또는 점수 상위 $K$개의 $y_{ij}$ 값을 기준으로 아이템을 추천 리스트로 생성한다.

2.5 TokenRec’s Training and Inference

1) Training

TokenRec은 고차원의 협업 정보(collaborative knowledge)를 ID 토크나이징에 반영하는 MQ-Tokenizer와 사용자 선호도를 포착하여 추천 아이템을 생성하는 LLM4Rec 백본으로 구성되어 있다. 두 컴포넌트를 동시에 학습하는 것이 직관적이지만, 양자화(quantization)와 언어 처리 간의 큰 차이로 인해 동기화된 업데이트가 어렵다. 따라서 다음의 두 단계로 나누어 학습을 수행한다.

Step 1. 사용자 및 아이템 MQ-Tokenizer 학습

사용자와 아이템의 ID 토크나이징을 학습하기 위해 먼저 MQ-Tokenizer를 학습하여 각자의 협업 표현을 독립적으로 양자화한다. 이때 손실 함수는 다음과 같다:

아이템 MQ-Tokenizer 학습 손실 : $$ \mathcal{L}^{Item}{MQ} = \mathcal{L}^{Item}{recon} + \mathcal{L}^{Item}{cb} + \beta^{Item} \cdot \mathcal{L}^{Item}{cm} $$
사용자 MQ-Tokenizer 학습 손실 : $$ \mathcal{L}^{User}{MQ} = \mathcal{L}^{User}{recon} + \mathcal{L}^{User}{cb} + \beta^{User} \cdot \mathcal{L}^{User}{cm} $$

Step 2. LLM4Rec 튜닝 (Generative Retrieval)

MQ-Tokenizer를 고정(freeze)한 후, LLM 백본(e.g. T5), LLM 토큰 임베딩, 프로젝션 레이어를 튜닝하여 생성적 검색(generative retrieval)을 수행한다. 이때의 목표는 사용자 표현 $z_i$가 관련된 아이템과 높은 유사도를 갖도록 학습하는 것이다.

추천 모델의 핵심은 metric learning을 기반으로 한 최근접 이웃(nearest neighbor) 검색이며, 사용자 표현 $z_i$와 협업 기반 GNN에서 학습된 아이템 표현 $q_j$ 간의 유사도를 이용하여 top-K 아이템을 선택한다.

튜닝을 위한 손실 함수는 다음의 pairwise ranking loss로 정의된다.

$$ \mathcal{L}_{LLM4Rec} = \begin{cases} 1 - \text{sim}(z_i, q_j), & \text{if } \lambda = 1 \ \max(0, \text{sim}(z_i, q_j) - \gamma), & \text{if } \lambda = -1 \end{cases} $$

$z_i$ : 사용자 $u_i$의 생성 아이템 표현
$q_j$ : 아이템 $v_j$의 협업 표현
$\text{sim}(\cdot, \cdot)$ : 코사인 유사도 등의 유사도 함수
$\lambda$ : 사용자 $u_i$가 아이템 $v_j$와 상호작용했는지 여부 ($\lambda = 1$이면 긍정, $-1$이면 부정)
$\gamma$ : 부정 샘플에 대한 마진 값

이 방식은 어렵고 혼동을 주는 샘플에 집중하도록 유도하여 효과적인 학습을 가능하게 한다.

2) Inference

기존 LLM 추론은 목표 토큰을 순차적으로 생성하는 방식이지만, 이는 느리고 학습되지 않은 사용자/아이템에 대한 일반화 성능이 낮다. TokenRec은 Generative Retrieval 프레임워크를 통해 이러한 문제를 해결한다.

효율적인 추천

TokenRec은 LLM을 활용하여 아이템 표현을 생성하고, 자연어 문장 대신 표현 벡터를 기반으로 아이템을 검색하므로, 시간 소모가 큰 디코딩 과정을 생략할 수 있다. 이로 인해 온라인 추천 시스템에서의 계산 비용이 크게 줄어든다.

새로운 사용자 및 아이템에 대한 범용성

TokenRec은 새로운 사용자나 아이템이 추가되더라도 MQ-Tokenizer와 LLM 백본을 재학습할 필요 없이, 협업 필터링 모델(GNN 등)만 업데이트하면 된다. 이 덕분에 빠른 적응과 높은 효율성을 보장할 수 있다. 이는 마스킹(Masking)과 K-way 인코딩 메커니즘 덕분이며, GNN 학습은 LLM 파인튜닝보다 훨씬 효율적이다.

새로운 사용자/아이템이 등장하더라도 전체 모델을 재학습할 필요는 없다.
GNN만 업데이트하면 되고, MQ-Tokenizer와 LLM은 고정된 상태로 활용 가능하다.
이로 인해 계산 비용이 절감되고 적응 속도가 빨라진다.

간결한 프롬프트

TokenRec은 사용자 ID 토큰만으로도 추천이 가능하다. 예를 들어, Prompt 1은 사용자 ID만 입력으로 사용한다. 이를 통해 입력 길이를 줄일 수 있어, 다수의 아이템과 상호작용한 사용자나 context 길이 제한이 있는 LLM에도 적합하다. (e.g. T5는 512 토큰, ChatGPT는 2048 토큰 제한)

3. Experiment

3.1 Experimental Settings

Datasets

Amazon-Beauty (Beauty) : Amazon 전자 상거래 플랫폼에서 가져온 Beauty 제품과의 사용자 상호 작용을 포함한다.
Amazon-Clothing (Clothing): Amazon 전자 상거래 플랫폼에서 가져온 Clothing 제품과의 사용자 상호 작용을 포함한다.
LastFM : Last.fm 온라인 음악 시스템의 사용자로부터 음악 아티스트 청취 기록을 제공한다.
MovieLens 1M (ML1M) : MovieLens 사용자가 만든 영화 평점 모음을 제공한다.

최대 아이템 시퀀스 길이는 LLM 백본 T5 (512 토큰)의 입력 길이를 수용하기 위해 100으로 설정된다.
훈련-검증-테스트 조합은 leave-one-out 정책을 따른다.
사용자의 상호 작용 이력을 무작위로 섞어 시간순이 아닌 아이템 목록을 제공한다.

Baselines

Collaborative Filtering : MF, NeuCF, LightGCN, GTN, LTGNN
- MF : 가장 고전적인 CF 방법
- NeuCF : 최초의 DNN 기반 협업 필터링
- LightGCN 및 GTN : GNN 기술을 기반으로 한 대표적인 CF
- LTGNN : 가장 발전된 GNN 기반 협업 필터링 방법
Sequential Recommendations : SASRec, BERT4Rec, S3Rec
- SASRec : self-attention 기반 순차적 추천 모델
- BERT4Rec : BERT 스타일 cloze 작업으로 훈련된 양방향 Transformer 기반 추천 모델
- S3Rec : self-supervised learning으로 훈련된 대표적인 순차적 추천 모델
LLM based Recommendations : P5, CID, POD, CoLLM
- P5 : LLM 기반 RecSys에 대한 선구적인 연구로, 추천 작업을 text-to-text 형식으로 설명하고 LLM을 사용하여 개인화 및 추천을 위한 더 깊은 의미를 포착한다. 실험에서 P5 모델에 임의 인덱싱(RID)과 순차 인덱싱(SID)의 두 가지 인덱싱 방법을 배포한다. 이 중에서 P5-SID는 실험에서 효율성 평가, 일반화 가능성 평가 및 제거 연구의 기준으로 선택된다.
- CID : 아이템의 동시 발생 행렬을 고려하여 숫자 ID를 설계하는 중요한 인덱싱 접근 방식이다. 따라서 사용자-아이템 상호 작용에서 함께 발생하는 아이템은 유사한 숫자 ID를 갖는다. 일관성을 유지하기 위해 P5 모델을 LLM 백본으로 사용한다.
- POD : P5 아키텍처를 기반으로 LLM의 과도한 입력 길이를 줄이기 위해 이산 프롬프트를 연속 임베딩으로 인코딩한다.
- CoLLM : GNN을 사용하여 LLM 기반 추천을 위한 아이템과 사용자를 나타내는 연속 임베딩을 제공한다. 특히, 실험에서 CoLLM의 이진 분류 출력은 상위 K개 추천의 출력 설정과 일치하도록 아이템 ID를 생성하도록 재구성된다.

Evaluation Metrics

상위 K개 Hit Ratio (HR@K)
상위 K개 Normalized Discounted Cumulative Gain (NDCG@K)
K 값은 10, 20, 30으로 설정되며, 그중 20은 ablation study의 기본값이다.

Hyper-parameter Settings

모델은 HuggingFace 및 PyTorch를 기반으로 구현된다.
코드북 수 K, 각 서브 코드북의 토큰 수 L, 마스킹 작업의 비율 $\rho$는 각각 {1, 2, 3, 4, 5}, {128, 256, 512, 1024} 및 0.1 단위로 {0 ~ 1} 범위에서 검색된다.
음수 샘플링 비율 $\lambda$는 1:1로 고정되고, 마진 $\gamma$는 0에서 0.2 사이로 설정된다.
MQ-Tokenizers와 LLM 백본은 미니 배치 방식으로 AdamW로 최적화한다.
사용자와 아이템에 대한 고차원 협업 표현은 LightGCN에서 얻는다.
프롬프팅을 위해 TokenRec에 대해 11개의 템플릿을 설계한다.
T5-small을 TokenRec 및 모든 LLM 기반 비교 대상에 사용한다.
비교 대상 방법의 다른 기본 하이퍼파라미터는 해당 논문에서 제안하는 대로 설정된다.

3.2 Performance Comparison of Recommender Systems

(User ID Only) : 아이템에 대한 사용자의 상호 작용 이력을 고려하지 않고 사용자 ID 토큰만 사용
(Unseen Prompt) : 새로운 사용자와 아이템에 대한 추천 성능을 평가하기 위한 프롬프트 사용

관찰 결과

관찰 1 : TokenRec은 최고의 성능을 달성하고 unseen 개인화 프롬프트가 있는 지표와 관련하여 모든 데이터 세트에서 모든 비교 대상보다 일관되게 뛰어나다.
- LastFM 데이터 세트에서 HR@20에서 19.08%, NCDG@20에서 9.09%로 가장 강력한 비교 대상을 크게 능가한다.
- 이는 제안하는 방법의 효과와 LLM 기반 RecSys에서 협업 인덱싱을 탐색할 수 있는 큰 잠재력을 보여준다.
관찰 2 : 사용자 ID 토큰만 사용하는 경우에도 TokenRec은 정확도 측면에서 대부분의 비교 대상을 능가하여 협업 추천에서 뛰어난 성능을 나타낸다.
- 이는 TokenRec이 사용자의 상호 작용 이력이 없는 경우에도 사용자를 효과적으로 모델링할 수 있음을 의미한다.
- TokenRec은 간결한 입력을 사용하여 추천을 생성할 수 있으므로 LLM에서 부과하는 입력 길이 제한을 피하고 상당한 계산 리소스를 절약할 수 있다.
관찰 3 : 협업 인덱싱(CID)은 동일한 P5 설정을 고려할 때 임의 인덱싱(RID) 및 순차 인덱싱(SID)보다 성능이 뛰어나다.
- 이는 아이템 및 사용자 토큰화/인덱싱을 위한 협업 지식 통합의 잠재력을 시사한다.
- P5 변형 및 POD는 기존 GNN 기반 협업 필터링보다 성능이 떨어지며, 이는 LLM을 사용하여 협업 정보를 포착하는 능력이 부족함을 의미한다.
관찰 4 : GNN 기반 협업 필터링 방법은 기존 CF 방법 및 대표적인 순차적 추천 방법보다 상대적으로 더 나은 성능을 보인다.
- 이는 고차원 연결성을 통해 협업 신호를 포착하는 데 있어 GNN의 효과를 입증한다.

3.3 Generalizability Evaluation

대부분의 전자 상거래 및 소셜 미디어 플랫폼에서는 상당수의 새로운 사용자 및 아이템이 매일 추천 시스템에 추가된다. 잘 확립된 시스템은 새로운 사용자의 선호도와 새로운 아이템의 특성을 수용하고 일반화하기 위해 자주 업데이트 및 개선을 수행해야 하므로 사용자 기반의 진화하는 역학에 맞는 개인화된 추천을 제공한다.

새로 추가된 사용자와 아이템은 LLM4Rec을 파인튜닝할 때 상호 작용이 부족하므로 기존 LLM 기반 RecSys는 잠재적 후보로 적합한 아이템을 검색하지 못하여 광범위한 재훈련이 필요하다. TokenRec은 사용자가 훈련 및 파인튜닝 코퍼스에 없는 경우에도 효과적으로 쉽게 일반화할 수 있다.

실험 설정

훈련 데이터 분할에서 상호 작용 이력이 가장 적은 5%의 사용자(unseen 사용자로 참조)를 제외하여 새로운 사용자를 시뮬레이션한다.
unseen 사용자에 대한 데이터 유출이 없는지 확인하기 위해 훈련 분할만 사용하여 이러한 LLM4Rec 모델을 설정하는 반면, unseen 사용자와 아이템의 협업 표현을 제공하기 위해 벡터 데이터베이스를 업데이트할 수 있다.
이는 LLM 기반 RecSys의 LLM 백본을 업데이트하는 것보다 훨씬 적은 계산 리소스를 소비한다.

관찰 결과

관찰 1 : 기존 LLM 기반 추천 방법은 P5 및 POD의 경우 unseen 사용자에게 아이템을 추천할 때 HR@20 및 NDCG@20에서 40% 이상의 상당한 감소로 입증되듯이 일반화 가능성에 어려움을 겪고 있다.
관찰 2 : CID 및 CoLLM에 협업 지식을 포함하면 P5 및 POD에서 성능 저하가 감소하는 것으로 나타나 모델 일반화에서 상대적으로 향상된 성능을 얻을 수 있다.
- 그러나 이러한 방법은 여전히 20% 이상의 감소를 경험하고 있으며, 이는 LLM 기반 추천에 대한 안정적인 ID 토큰화의 중요성을 간과하고 있음을 나타낸다.
관찰 3 : TokenRec은 훈련 사용자뿐만 아니라 두 데이터 세트의 unseen 사용자에 대해서도 모든 비교 방법을 능가한다.
- Amazon-Beauty 데이터 세트에서 TokenRec의 성능은 평균 7%만 감소하여 새로 추가된 사용자에 대한 TokenRec의 강력한 일반화 기능을 입증한다.
- 이러한 우수성은 강력한 ID 토큰화를 위한 MQ-Tokenizer와 유연한 추천 생성을 위한 생성적 검색 패러다임에 기인할 수 있다.

3.4 Efficiency Evaluation

제안하는 방법은 텍스트 디코딩 생성 솔루션을 버리고 협업 추천을 수행하기 위한 생성적 검색 패러다임을 도입한다.
TokenRec이 LLM 기반 추천 baseline에 비해 약 1306.5%의 상당한 개선으로 뛰어난 추론 효율성을 달성할 수 있음을 보여준다.
이는 LLM의 가장 시간이 많이 걸리는 자동 회귀 디코딩 및 빔 검색 프로세스를 우회하는 생성적 검색 패러다임에 기인할 수 있다.

3.5 Ablation Study

제안하는 주요 구성 요소의 효과를 평가하기 위해 LastFM 및 Amazon-Beauty 데이터 세트에서 제거 실험을 수행했으며, 각 구성 요소의 영향은 다음과 같이 개별적으로 제거되었다.
- w/o High-Order Collaborative Knowledge (HOCK) : MF를 사용하여 MQ-Tokenizers에서 ID 토큰화를 위한 사용자와 아이템의 협업 표현을 학습한다.
  - MF는 사용자-아이템 상호 작용 간의 고차원 협업 신호를 명시적으로 포착하기가 어렵다.
- w/o K-way : K-way 인코더 및 코드북을 코드북 토큰의 총 수를 일관되게 유지하면서 1-way로 대체한다.
- w/o Masking : 사용자 및 아이템 MQ-Tokenizers에서 마스킹 작업을 비활성화한다.

관찰
- 접근 방식의 각 구성 요소는 전체 성능에 기여하므로 제거하면 성능 저하가 발생한다.
- 접근 방식에 도입된 마스킹 작업 및 K-way 프레임워크는 일반화 가능성을 향상시킬 뿐만 아니라 제거 실험 중에 적당한 성능 향상을 가져온다.
- 고급 GNN으로 학습된 고차원 협업 지식을 제거하면 성능이 크게 저하되었다. 이는 LLM 및 개인화된 추천을 정렬하기 위해 그러한 지식을 통합하는 것이 중요하다는 것을 나타낸다.

3.6 Hyper-parameter Analysis

TokenRec에서는 벡터 양자화의 마스킹 비율 $\rho$, 서브 인코더/서브 코드북 수 K, 각 서브 코드북의 토큰 수 L이라는 세 가지 중요한 하이퍼파라미터를 도입한다. 제안하는 모델의 향후 적용을 용이하게 하기 위해 이러한 값의 민감도를 이 섹션에서 평가한다.

Effect of Masking Ratio $\rho$

사용자 및 아이템 ID 토큰화를 위한 벡터 양자화의 마스킹 비율을 제어하는 MQ-Tokenizer의 하이퍼파라미터 $\rho$의 영향을 조사한다.

작은 비율의 마스킹을 도입하면 성능이 향상된다는 것을 알 수 있다.
대부분의 경우 제안하는 방법의 추천 성능은 $\rho < 0.5$일 때 향상되며, 그중 0.2가 실험에서 최고의 개선을 달성할 수 있다.
실험 결과는 마스킹 비율 $\rho >= 0.5$일 때 추천 성능이 저하되어 과도한 마스킹을 피해야 함을 시사한다.

Effect of Codebook Settings K and L

제안하는 방법 TokenRec이 더 많은 서브 코드북을 쌓고 더 많은 코드북 토큰을 도입하여 이점을 얻을 수 있는지 여부를 연구하기 위해 하이퍼파라미터 K와 L의 수를 각각 {1, 2, 3, 4, 5} 및 {128, 256, 512, 1024} 범위에서 변경하고 모든 데이터 세트에 대한 성능을 확인한다.

코드북 깊이가 증가함에 따라 모든 데이터 세트에서 추천을 위한 모델의 점진적인 성능 향상이 확인된다.
- 그럼에도 불구하고 K > 3이면 추천 성능의 향상이 상대적으로 미미해진다.
- 결과적으로 효과와 효율성 간의 절충을 고려하여 K = 3이 제안된다.
L의 최적 값은 사용자와 아이템의 크기에 따라 다르다.
- LastFM/ML1M (더 작은 크기) 및 Amazon-Beauty/Clothing (더 큰 크기) 데이터 세트에서 각각 L이 256 및 512일 때 효과와 효율성 측면에서 가장 균형 잡힌 성능을 관찰할 수 있다.
- 이는 사용자/아이템이 더 많은 데이터 세트의 경우 각 서브 코드북에서 약간 더 많은 코드북 토큰을 사용해야 함을 의미한다.
단일 코드북의 경우 단순히 코드북 토큰 수를 늘리는 것만으로는 추천에서 성능 향상을 효과적으로 제공할 수 없다.
- 이는 추천을 위한 MQ-Tokenizer에서 제안하는 K-way 메커니즘의 효과를 입증한다.

Collaborative Filtering

CF는 사용자 선호도에 따라 개인화된 추천을 제공하기 위해 사용자-아이템 상호 작용과 같은 협업 정보를 모델링하는 대표적인 기술이다. 유사한 사용자 패턴을 포착하고 미래의 상호 작용을 예측하는 데 사용된다.
- MF : 사용자와 아이템을 조밀한 표현으로 벡터화하고, 벡터 간의 내적을 계산하여 상호 작용을 모델링한다.
- NeuCF : 신경망과 MF를 통합하여 사용자 및 아이템 임베딩을 나타내는 저차원 행렬로 사용자-아이템 상호 작용을 분해한다.
- DSCF : 소셜 네트워크에서 이웃 정보를 활용하여 협업 추천을 위한 사용자 표현을 향상시키기 위해 심층 언어 모델을 사용한다.
GNN : LightGCN, GTN, LTGNN 등은 사용자-아이템 상호 작용 그래프에서 고차원 협업 지식을 포착하여 추천 시스템 성능을 향상시킨다. 사용자-아이템 상호 작용의 그래프 구조적 특성을 활용하고, 정보 전파를 통해 유사한 사용자 행동 패턴을 모델링한다.
- GraphRec : 소셜 추천을 위해 사용자-아이템 상호 작용과 사용자-사용자 소셜 관계를 인코딩하는 그래프 주의 네트워크 기반 프레임워크를 사용한다.
- LightGCN : 기능 변환 및 비선형 활성화를 제거하여 GNN 기반 추천 방법을 단순화하고 최첨단 예측 성능을 달성한다.
- GTN & LTGNN : 각각 상호 작용의 적응형 신뢰성 및 고차원 시간 패턴을 포착하여 성능을 개선한다.

LLM-based Recommender Systems

ChatGPT, GPT-4와 같은 LLM의 발전으로 자연어 처리 기술이 혁신되었고, LLM 기반 추천 시스템이 주목받고 있다. LLM의 뛰어난 성능은 거대한 훈련 데이터와 모델 크기 확장에 기인한다. 수십억 개의 파라미터를 가진 LLM은 뛰어난 일반화 능력과 추론 능력을 보여준다.
- LLM을 추천 작업에 적용하기 위해 사전 훈련, 파인튜닝, 프롬프팅(e.g. in-context learning, chain-of-thought, instruction tuning)과 같은 다양한 패러다임이 연구되고 있다.
- P5 : 다중 작업 프롬프트 기반 사전 훈련을 통해 다양한 추천 작업을 통합하고, 개인화된 프롬프트로 새로운 추천 작업에 대한 제로 샷 일반화 기능을 달성한다.
LLM 기반 추천 방법은 사용자 및 아이템 ID 인덱싱에 제한이 있으며, 독립 인덱싱(IID)은 언어 모델 내에서 사용자 및 아이템을 나타내기 위해 특수 토큰을 직접 할당한다. 텍스트 제목 인덱싱은 LLM 어휘 내 토큰을 사용하여 아이템을 토큰화한다.
- P5, POD 등은 아이템과 사용자를 나타내는 토큰을 강조하기 위해 위치 및 전체 단어 임베딩을 적용한다. 최근에는 소프트 프롬프트를 사용하여 연속 임베딩으로 사용자 및 아이템을 나타내기도 한다.
제목 인덱싱 및 전체 단어 임베딩은 어휘 폭발 문제를 완화할 수 있지만, 고차원 협업 지식 포착에 어려움이 있고, 새로운 사용자/아이템에 대한 일반화 가능성이 부족하다. 언어 모델에서 토큰의 이산적인 특성은 연속적인 표현을 사용할 때 LLM 정렬을 어렵게 만든다. 또한, 대부분의 LLM 기반 추천 시스템은 자동 회귀 디코딩 및 빔 검색으로 인해 추론 시간이 오래 걸린다.
따라서 본 논문에서는 고차원 협업 지식을 포착하고 효율적인 생성적 검색 패러다임을 제안하는 LLM 기반 추천을 위한 새로운 프레임워크인 TokenRec을 제안한다. 이는 기존 방법들의 단점을 극복하고 더 효과적인 추천 시스템을 구축하기 위함이다.

5. Conclusion

기존의 LLM 기반 추천 방법은 유망한 예측 성능을 달성하지만, 사용자 및 아이템을 토큰화하는 데 있어 고차원 협업 지식을 포착하지 못하고 열악한 일반화 기능을 겪는다. 또한 시간이 오래 걸리는 추론은 LLM 기반 추천 시스템에서 새로운 과제로 남아 있다.
이러한 단점을 해결하기 위해 고차원 협업 지식을 포착하기 위한 일반화 가능한 사용자 및 아이템 ID 토큰화 전략을 도입할 뿐만 아니라 상위 K 아이템의 효율적인 생성을 위한 생성적 검색 패러다임을 제시하는 TokenRec이라는 새로운 접근 방식을 제안한다.
마스크된 벡터 양자화 토크나이저 (MQ-Tokenizer)는 고차원 협업 지식을 통합하여 LLM 기반 추천에서 사용자와 아이템을 토큰화하기 위해 개발되었다.
4개의 데이터셋에 대한 실험을 통해 TokenRec은 SOTA 추천 성능을 달성했을 뿐만 아니라 unseen 사용자에 대한 일반화 능력을 보여주었다.

[논문] Learnable Item Tokenization for Generative Recommendation

Thu, 10 Apr 2025 06:34:59 GMT

📄 Paper

Learnable Item Tokenization for Generative Recommendation [arxiv]

Wenjie Wang CIKM 24

📝 3줄 요약

LLM을 활용한 생성형 추천 시스템을 개선하기 위해, 효과적인 아이템 토큰화 방법을 제안한다.
기존의 ID, 텍스트, 코드북 기반 식별자들의 한계를 해결하기 위해, 계층적 의미, 협업 신호, 코드 할당 다양성을 통합한 학습 가능한 토큰화 모델인 LETTER를 제안한다.
LETTER는 RQ-VAE를 활용한 의미 정규화, 대조적 정렬 Loss를 통한 협업 정규화, 그리고 코드 할당 편향을 완화하는 다양성 정규화를 적용하여 최신 생성형 추천 기술을 한 단계 더 발전시켰다.

Abstract

문제 제기 및 배경

최근 생성적 추천(Generative Recommendation) 분야에서 LLM 활용이 활발하다.
하지만 추천 데이터를 LLM의 언어 공간으로 효과적으로 변환하는 아이템 토큰화 방식에 대한 연구가 미흡하다.
기존 토큰화 방식(ID, 텍스트, 코드북 기반)은 의미 정보 인코딩, 협력 신호 통합, 코드 할당 편향 등의 문제점을 가진다.

제안하는 방법: LETTER (Learnable Tokenizer for Generative Recommendation)

개념 : 계층적 의미, 협력 신호, 코드 할당 다양성을 통합하여 식별자의 필수 요건을 충족하는 학습 가능한 토크나이저
핵심 기술 :
- 의미 정규화 : 잔여 양자화 VAE (Residual Quantized VAE) 활용
- 협력 정규화 : 대조적 정렬 Loss 활용
- 코드 할당 편향 완화 : 다양성 Loss 활용
추가 개선 : 순위 기능 향상을 위한 순위 안내 생성 Loss 제안

실험 결과 및 결론

세 가지 데이터셋에서 LETTER를 평가한 결과, LLM 기반 생성 추천 분야에서 최고 수준의 성능을 달성했다.
LETTER는 기존 토큰화 방식의 한계를 극복하고, LLM을 활용한 생성적 추천 성능을 향상시키는 효과적인 방법임을 입증했다.

code assignment bias

아이템 토크나이제이션 과정에서 코드가 아이템에 비균등하게 할당되는 현상을 말한다. 일부 코드가 특정 아이템에 과도하게 할당되거나, 반대로 특정 코드가 거의 사용되지 않는 경우가 발생할 수 있다. 이렇게 되면 코드의 분포가 불균형해지고, 결과적으로 생성 모델이 특정 코드(또는 아이템)를 더 자주 생성하게 되는 아이템 생성 편향으로 이어질 수 있다.

code : 의미적으로 풍부하고 계층화된 토큰의 집합으로, 아이템을 표현하기 위한 특별한 형태의 토큰

Figure

Item Tokenization : 계층적 의미, 협력 신호, 다양성을 통합하여 아이템의 의미 정보를 토큰화한다.
Next-Item Generation : 토큰화한 사용자의 상호작용 정보를 생성적 추천 모델에 입력하여 다음 아이템을 생성한다.

LETTER는 세 가지 정규화를 사용한다.

Semantic Regularization : 의미 인코딩을 보장한다.
Collaborative Regularization : 식별자의 코드 시퀀스와 협업 신호 간의 정렬을 강화한다.
Diversity Regularization : 코드 할당 편향을 완화한다.

1. Introduction

1. 배경

생성적 추천에 LLM 활용이 중요 연구 분야로 부상하고 있다.
생성적 추천은 사용자가 과거에 상호 작용한 아이템을 기반으로 LLM을 사용하여 목표 아이템을 추천으로 생성하는 것을 목표로 한다.
LLM을 통해 아이템을 인코딩하고 생성하는 데 핵심적인 문제는 아이템 토큰화이다.
아이템 토큰화는 각 아이템을 식별자(토큰 시퀀스)를 통해 인덱싱하여 추천 데이터와 LLM의 언어 공간 사이의 간극을 해소한다.

2. 기존 아이템 토큰화 방식의 문제점

ID 식별자
- 각 아이템에 고유한 숫자 문자열을 할당하여 고유성을 보장한다.
- 의미 정보를 효율적으로 인코딩하지 못하므로 콜드 스타트 아이템을 일반화하는 데 어려움이 있다.
텍스트 식별자
- 아이템 제목, 속성, 설명 등 의미 정보를 직접 활용한다.
- 의미 정보가 식별자의 토큰 시퀀스에서 계층적으로 분산되지 않는다.
- 사용자 행동에서 얻어지는 협업 신호가 부족하다.
코드북 기반 방법
- 자동 인코더를 사용하여 아이템 의미를 계층적 코드 시퀀스로 인코딩한다.
- 텍스트 식별자와 유사하게 코드 시퀀스에 협업 신호가 부족하다.
- 아이템에 코드를 할당하는 것이 불균형하며, 빈도가 높은 코드를 가진 아이템이 더 쉽게 생성되는 아이템 생성 편향을 유발한다.

3. 이상적인 식별자의 기준

계층적 의미를 식별자에 통합 : 토큰 시퀀스가 처음에는 광범위하고 거친 수준의 의미를 인코딩하고 점진적으로 더 세련되고 세밀한 세부 사항으로 전환한다.
협업 신호를 토큰 할당에 통합 : 사용자 행동에서 유사한 협업 신호를 가진 아이템이 식별자로서 유사한 토큰 시퀀스를 갖도록 한다.
토큰 할당의 다양성 향상 : 아이템 생성 편향을 완화하여 아이템 생성의 다양성을 보장한다.

4. 제안 방법 : LETTER (Learnable Tokenizer for Generative Recommendation)

코드북 기반 식별자를 개선하기 위해 세 가지 종류의 정규화를 통합한다.
- 의미 정규화 : RQ-VAE(Residual Quantized VAE)를 통합하여 아이템 의미 정보를 계층적 식별자로 변환한다.
- 협업 정규화 : Contrastive Alignment Loss를 사용하여 RQ-VAE의 의미 양자화 임베딩을 잘 훈련된 CF 모델의 CF 임베딩과 정렬한다.
- 다양성 정규화 : Diversity Loss를 사용하여 코드 임베딩 다양성을 향상시켜 코드 할당 편향 및 아이템 생성 편향을 완화한다.
LETTER를 두 개의 대표적인 생성적 추천 모델에 적용하고, 생성적 모델의 순위 능력을 이론적으로 향상시키기 위해 순위 기반 생성 Loss를 제안한다.

5. 실험 결과

세 개의 데이터 세트에 대한 광범위한 실험과 심층적인 조사를 통해 LETTER가 식별자에서 계층적 의미, 협업 신호 및 코드 할당 다양성을 동시에 고려하여 우수한 아이템 토큰화를 달성할 수 있음을 입증했다.

6. 기여

이상적인 식별자의 필요한 특징을 포괄적으로 분석하고, 새로운 학습 가능한 토크나이저 LETTER를 제안한다.
LETTER를 생성적 추천 모델에 적용하고 순위 기반 생성 Loss를 활용하여 생성적 추천 모델의 순위 능력을 이론적으로 향상시킨다.
다양한 설정을 통한 심층적인 조사와 함께 세 개의 데이터 세트에 대한 광범위한 실험을 수행하여 LETTER가 기존 아이템 토큰화 방법보다 성능이 우수함을 입증한다.

2. Item Tokenization

1. 아이템 토큰화의 중요성

LLM 기반 생성적 추천의 핵심 단계는 각 아이템에 식별자를 할당하는 아이템 토큰화다.
각 식별자는 LLM이 아이템을 인코딩하고 생성하는 데 도움을 주는 토큰 시퀀스다.
아이템 토큰화를 통해 LLM 기반 모델은 사용자 과거 상호 작용을 식별자 시퀀스로 변환하고, 다음 아이템 추천을 위해 아이템 식별자를 자동 회귀적으로 생성할 수 있다.

2. 기존 아이템 토큰화 방법의 한계

기존 방법은 ID 식별자, 텍스트 식별자, 코드북 기반 식별자를 사용한다.
ID 식별자는 의미 인코딩 기능이 부족하다.
텍스트 및 코드북 기반 식별자는 다음과 같은 문제점을 가진다.
- 비계층적 의미 : 텍스트 식별자에서 의미 정보가 계층적으로 분산되지 않는다.
- 협업 신호 부족 : 토큰 시퀀스 구성 시 협업 신호를 고려하지 않는다. 비슷한 의미의 아이템은 비슷한 토큰 시퀀스를 공유하므로 협업 신호와 정렬하기 어렵다.
- 코드 할당 편향 : 코드북 기반 방법은 불균형한 코드 할당으로 인해 아이템 생성 편향이 발생한다. 인기있는 아이템 식별자가 생성될 가능성이 더 높다.

3. 이상적인 식별자의 목표

토큰 시퀀스와의 계층적 의미 통합
토큰 시퀀스에서의 협업 신호 통합
코드 할당의 높은 다양성 확보

3. Method

3.1 LETTER

LETTER : LEarnable Tokenizer for generaTivE Recommendation

LETTER는 LLM 기반 생성 추천(generative recommendation)을 위한 아이템 토크나이저(tokenizer)로, 세 가지 주요 목표를 달성하기 위해 설계되었다. 이 모델은 계층적인 의미를 가지는 식별자(identifier)를 생성하며, 협업 신호를 반영하고, 코드 할당 편향 문제를 완화하기 위한 정규화 기법들을 포함한다.

Semantic Regularization

LETTER는 계층적 의미를 갖는 식별자를 생성하기 위해 RQ-VAE에 기반한다. RQ-VAE는 다단계 임베딩 양자화 방식으로, semantic residual을 반복적으로 양자화하여 의미의 거칠고 세밀한 수준을 모두 포착할 수 있도록 한다.

의미 임베딩 추출 : 아이템의 제목이나 설명 등 콘텐츠 정보를 바탕으로 사전 학습된 의미 추출기(e.g. LLaMA-7B)를 사용하여 의미 임베딩 $s$를 추출한다. 이 임베딩은 인코더를 통해 잠재 의미 임베딩 $z \in \mathbb{R}^d$로 압축된다.
의미 임베딩 양자화 : $z$는 $L$개의 코드북을 거쳐 양자화된다. 각 단계 $l$에서 의미 잔차 $r_{l-1}$과 가장 유사한 코드 임베딩 $e_i$를 선택하여 $r_l = r_{l-1} - e_{c_l}$로 업데이트하며, 최종적으로 식별자 $\tilde{i} = [c_1, c_2, ..., c_L]$를 생성한다.
Loss 함수 구성 : 의미 정규화를 위한 전체 Loss은 다음과 같다. $$ L_{\text{Sem}} = L_{\text{Recon}} + L_{\text{RQ-VAE}} $$
- $L_{\text{Recon}}$은 의미 임베딩의 재구성을 위한 Loss로, $| s - \hat{s} |^2$로 정의된다.
- $L_{\text{RQ-VAE}}$는 각 단계에서의 양자화 오차를 줄이며 인코더와 코드 임베딩을 공동 학습한다.

이를 통해 LETTER는 계층적 의미를 반영한 코드 시퀀스를 생성할 수 있으며, 이를 바탕으로 세분화된 생성이나 콜드스타트 상황에서의 일반화를 용이하게 한다.

Collaborative Regularization

LETTER는 단순히 의미 정보만을 반영하는 것이 아니라, 협업 필터링(CF) 기반 추천 시스템에서의 협업 신호를 코드 시퀀스에 반영하기 위해 협업 정규화를 도입한다.

정규화 방식 : 학습된 CF 모델(SASRec, LightGCN 등)을 활용하여 아이템의 CF 임베딩 $h$를 얻고, 양자화된 임베딩 $\hat{z}$와 정렬시킨다. 이 과정을 위해 대조 학습 기반의 Loss 함수 $L_{\text{CF}}$를 사용한다.
협업 정규화는 협업적으로 유사한 아이템들이 유사한 코드 시퀀스를 갖도록 유도한다. 이는 기존 TIGER와 같은 모델이 의미 정보에만 의존하는 방식과 차별화된다.

Diversity Regularization

코드 임베딩의 불균형한 분포는 코드 할당 편향을 초래할 수 있다. 이를 해결하기 위해 LETTER는 다양성 정규화를 적용한다.

정규화 방식 : 각 코드북 내 임베딩을 제약된 K-means로 클러스터링한 후, 동일 클러스터 내 임베딩은 끌어당기고(closing), 다른 클러스터 간 임베딩은 밀어내는(push apart) 방식의 Loss 함수 $L_{\text{Div}}$를 정의한다.
코드 임베딩 분포의 균형을 맞춤으로써 코드 할당 편향 문제를 완화하고, 더욱 균등하고 다양한 코드 시퀀스를 생성할 수 있다.

Overall Loss

$$ L_{\text{LETTER}} = L_{\text{Sem}} + \alpha L_{\text{CF}} + \beta L_{\text{Div}} $$

여기서 $\alpha$와 $\beta$는 협업 및 다양성 정규화의 기여도를 조절하는 하이퍼파라미터이다.

3.2 Instantiation

LETTER를 LLM 기반 생성 추천 모델에 적용하기 위해 먼저 추천 아이템을 대상으로 LETTER를 학습시킨다. 이후 학습이 완료된 LETTER는 LLM의 학습 및 추론 과정에서 아이템을 토크나이징하는 데 활용된다.

cf. Instantiation : 인스턴스화 (적용, 구현) cf. 인스턴스화 : 클래스(class)에서 특정 객체(object)를 생성하는 과정

3.2.1 Training

생성 추천 모델의 학습은 아이템 토크나이징과 모델 최적화의 두 단계로 구성된다.

아이템 토크나이징 : 사전 학습된 LETTER를 사용하여 각 아이템을 식별자 $\tilde{i} = [c_1, c_2, ..., c_L]$로 인덱싱한다. 이후 사용자의 상호작용 이력을 식별자 시퀀스로 변환한다. 학습 데이터셋은 $D = {(x, y)}$ 형태이며, 여기서 $x = [\tilde{i}1, \tilde{i}_2, ..., \tilde{i}_M]$는 사용자의 시간 순 상호작용 시퀀스를, $y = \tilde{i}{M+1}$는 다음 상호작용 아이템의 식별자를 의미한다.
순위 기반 생성 Loss (Ranking-guided Generation Loss) : 기존 연구에서는 Generation Loss를 통해 LLM을 학습시키지만, 이는 아이템 전체에 대한 순위 최적화를 고려하지 않아 추천 성능을 저해할 수 있다. 이를 개선하기 위해 LETTER는 순위 기반 생성 Loss인 $L_{\text{rank}}$을 제안한다.

이 Loss 함수는 어려운 부정 샘플(hard negatives)에 대해 더 큰 패널티를 주는 방식으로 설계되었으며, 온도 파라미터 $\tau$를 조정함으로써 모델의 순위 예측 능력을 향상시킨다. $$ L_{\text{rank}} = -\sum_{t=1}^{|y|} \log P_\theta(y_t | y_{
명제 :
- $L_{\text{rank}}$ 최소화는 사용자에 대해 hard-negative 아이템을 최적화하는 것과 동치이다. 작은 $\tau$ 값일수록 hard-negative에 대한 패널티가 강화된다.
- 이 Loss 함수는 one-way partial AUC 최적화와 관련이 있으며, 이는 Recall, NDCG와 같은 순위 기반 평가 지표와 강하게 연관되어 있으므로 top-K 추천 성능을 향상시킬 수 있다.

3.2.2 Inference

추론 시, 생성 추천 모델은 다음 아이템을 생성하기 위해 식별자 코드 시퀀스를 autoregressive 방식으로 생성한다. 이 과정은 다음과 같이 정의된다: $$ \hat{y}t = \arg\max{v \in V} P_\theta(v | \hat{y}_{

Autoregressive

Autoregressive는 자기회귀라는 뜻으로, 이전 값들을 기반으로 현재 또는 미래 값을 예측하는 모델이나 기법을 의미한다. 이는 주로 시계열 데이터 분석이나 생성형 AI에서 사용된다. 자기회귀 모델은 현재 값이 과거 값의 함수라고 가정하며, 과거 데이터의 패턴을 학습하여 다음 값을 예측한다.

4. Experiments

RQ1 : LETTER는 다른 종류의 식별자들과 비교했을 때 얼마나 잘 작동할까? RQ2 : LETTER의 구성 요소들, 예를 들어 협업 정규화나 다양성 정규화는 성능에 어떤 영향을 줄까? RQ3 : 식별자 길이, 코드북 크기, 정규화 강도, 온도 같은 다양한 설정에서 LETTER는 어떻게 작동할까?

4.1 Experimental Settings

Datasets

Instruments, Beauty : 아마존 리뷰 데이터 세트에서 가져온 것들이다.
Yelp2 : Yelp 플랫폼의 데이터 세트이다.
데이터 전처리 과정 : 희소한 사용자나 아이템은 제거하고, 순차 추천 설정에 맞춰 데이터를 나누고, 사용자 기록 아이템 수는 20개로 제한한다.

Baselines

다양한 유형의 식별자 (ID, 텍스트, 코드북 기반)를 사용하는 모델들을 포함한다.

기존 추천 모델

MF : 잠재 공간에서 사용자-아이템 상호 작용을 사용자 임베딩과 아이템 임베딩으로 분해한다.
Caser : 컨볼루션 신경망을 사용하여 사용자의 공간 및 위치 정보를 포착한다.
HGN : 그래프 신경망을 활용하여 사용자-아이템 상호 작용을 예측하기 위한 사용자 및 아이템 표현을 학습한다.
BERT4Rec : BERT의 사전 훈련된 언어 표현을 활용하여 의미적 사용자-아이템 관계를 포착한다.
LightGCN : 사용자와 아이템 간의 고차 연결에 초점을 맞춘 경량 그래프 컨볼루션 네트워크 모델이다.
SASRec : self-attention 메커니즘을 사용하여 사용자 상호 작용 기록에서 장기 종속성을 포착한다.

LLM 기반 생성적 추천 모델

BIGRec : 텍스트 식별자를 사용하는 LLM 기반 생성적 추천 모델로, 각 아이템은 해당 제목으로 표현된다.
P5-TID : LLM 기반 생성적 추천 모델에 아이템 제목을 텍스트 식별자로 사용한다.
P5-SemID : 아이템 메타데이터(e.g. 속성)를 활용하여 LLM 기반 생성적 추천 모델에 대한 ID 식별자를 구성한다.
P5-CID : 아이템 공동 출현 그래프에서 파생된 스펙트럼 클러스터링 트리를 통해 LLM 기반 생성적 추천 모델에 대한 식별자에 협업 신호를 통합한다.
TIGER : RQ-VAE를 통해 코드북 기반 식별자를 도입하여 LLM 기반 생성적 추천을 위해 의미 정보를 코드 시퀀스로 양자화한다.
LC-Rec : 코드북 기반 식별자와 보조 정렬 작업을 사용하여 생성된 코드 시퀀스를 자연어와 연결하여 LLM의 지식을 더 잘 활용한다.

Evaluation Settings

top-K Recall(R@K)과 NDCG(N@K)를 지표로 사용하며, K는 5와 10으로 설정한다.

Implementation Details

LETTER는 TIGER와 LC-Rec라는 대표적인 LLM 기반 생성적 추천 모델에 적용하여 실험한다.

TIGER / LC-Rec 설정

TIGER는 논문에 제시된 내용을 바탕으로 직접 구현한다.
LC-Rec는 파라미터 효율적인 파인튜닝 기법인 LoRA를 사용하여 LLaMA-7B 모델을 파인튜닝한다.
- 아이템 의미 임베딩을 얻기 위해 LLaMA-7B를 활용한다.
- 협업 정규화를 위해 SASRec에서 추출한 32차원 아이템 임베딩을 사용한다.
- 다양성 정규화에서는 클러스터 개수 K를 10으로 설정한다.
실험은 4개의 NVIDIA RTX A5000 GPU를 사용한다.

LETTER 설정

RQ-VAE는 4레벨 코드북을 사용하며, 각 코드북은 32차원의 256개 코드 임베딩으로 구성된다.
AdamW 옵티마이저를 사용하며, 학습률은 1e-3, 배치 크기는 1,024로 설정하여 20,000 에폭 동안 훈련한다.
하이퍼파라미터 튜닝을 통해 최적의 성능을 찾는다. (𝜇 = 0.25, 𝛼는 {1e-1, 2e-2, 1e-2, 1e-3}, 𝛽는 {1e-2, 1e-3, 1e-4, 1e-5} 범위에서 탐색)
TIGER와 LC-Rec 모델을 파인튜닝할 때도 유효성 검사 성능을 기준으로 학습률을 조정한다.

4.2 Overall Performance (RQ1)

목표 : 다양한 모델들과 비교하여 LETTER의 전반적인 성능을 평가한다.
방법 : 두 개의 SOTA LLM 기반 생성적 추천 모델(TIGER, LC-Rec)에 LETTER를 적용하여 성능을 측정하고 비교한다. (LETTER-TIGER, LETTER-LC-Rec)

ID 식별자 기반 모델 비교

P5-CID가 P5-SemID보다 전반적으로 우수한 성능을 보인다.
P5-SemID의 단점 : 아이템 카테고리 기반 식별자 할당으로 인해 세분화된 의미 정보를 포착하지 못하고, 의미-협업 신호 불일치가 협업 학습을 방해한다.
P5-CID의 장점 : 아이템 공동 출현 그래프의 협업 신호를 활용하고, 사용자 행동에서 협업 패턴을 포착한다.

다양한 식별자 기반 모델 비교

코드북 기반 식별자를 사용하는 모델(TIGER, LC-Rec)이 ID/텍스트 식별자 기반 모델보다 우수하다.
이유 : RQ-VAE로 여러 단계의 의미를 합쳐서 세세한 정보를 파악하고, 비슷한 아이템을 더 잘 구별한다.
텍스트 식별자 모델(BIGRec, P5-TID)의 약점 : 아이템 의미랑 실제 상호작용이 안 맞아서 협업 신호 학습이 잘 안 될 수 있다.

LETTER의 효과

LETTER는 TIGER, LC-Rec에 적용했을 때 뚜렷한 성능 향상을 보인다.
이유 :
- CF 통합: 협업 신호와 의미 임베딩을 정렬하고, 유사한 아이템이 유사한 코드 시퀀스를 갖도록 하여 의미-협업 신호 불일치 문제를 해결한다.
- 향상된 토큰 할당 다양성: 코드 임베딩 표현 공간 정규화하여 코드 할당 편향으로 인한 아이템 생성 편향을 완화한다.

4.3 In-depth Analysis

4.3.1 Ablation Study (RQ2)

목표 : 각 정규화 방법이 성능에 미치는 영향을 분석한다.
방법 : TIGER에 대한 다섯 가지 LETTER 변형을 비교한다.
- TIGER : 의미 정규화만 사용
- TIGER w/ c. r. : 의미 및 협업 정규화 사용
- TIGER w/ d. r. : 의미 및 다양성 정규화 사용
- (1) w/ d. r. : 의미, 협업, 다양성 정규화 사용, 원래 생성 Loss로 훈련
- LETTER-TIGER : 모든 정규화 사용, 순위 기반 생성 Loss 적용
결과 :
- 협업 또는 다양성 정규화를 사용하면 TIGER의 성능이 향상된다. (협업 신호 주입, 코드 임베딩 다양성 개선 효과 확인)
- 세 가지 정규화를 모두 사용하여 아이템 토큰화를 최적화하면 성능이 더욱 향상된다. (코드 할당 시 의미와 협업 정보를 모두 고려하는 효과)
- LETTER-TIGER는 순위 기반 생성 Loss를 활용하여 최고의 성능을 달성한다. (온도 조절을 통해 어려운 부정적 샘플을 억제하여 순위 능력 강화)

4.3.2 Code Assignment Distribution (RQ2)

목표 : 다양성 정규화가 아이템 토큰화에서 코드 할당 편향을 완화하는지 확인한다.
방법 :
- 다양성 정규화 유무에 따른 TIGER의 첫 번째 코드 분포를 비교한다.
- 다양성 및 협업 정규화 유무에 따른 TIGER의 첫 번째 코드 분포를 비교한다.
- 각 토큰화 방식에 대해 잘 훈련된 토크나이저로 아이템을 토큰화한 후, 첫 번째 코드를 빈도에 따라 정렬하고 그룹으로 나눈다.
결과 :
- 다양성 정규화를 사용하면 첫 번째 코드의 분포가 더 균일해져 코드 할당 편향을 완화하고 아이템 생성 편향을 줄일 수 있다.
- 다양성 정규화는 첫 번째 수준 코드북에서 코드 활용률을 높여 코드 할당의 다양성을 향상시킨다.
- 협업 정규화를 추가하면 코드 활용도가 감소하지만, 다양성 정규화를 통해 코드 활용도 감소를 보상한다.
- LETTER는 협업 신호를 캡처하고 높은 코드 활용도를 유지하여 이상적인 식별자의 여러 기준을 동시에 충족한다.

4.3.3 Code Embedding Distribution (RQ2)

목표 : 다양성 정규화가 코드 임베딩의 편향된 분포를 완화하는지 분석한다.
방법 :
- 다양성 정규화 유무에 따른 LETTER의 코드 임베딩을 시각화한다.
- 첫 번째 수준 코드북에서 코드 임베딩을 얻은 후 PCA를 통해 3차원 공간으로 차원 축소한다.
- 3차원 코드 임베딩을 구형 플롯에 표시하고, 각 점은 코드 임베딩 벡터를 나타내며, 더 어두운 색상은 더 많은 아이템에 할당된 코드를 나타낸다.
결과 :
- 다양성 정규화가 있는 LETTER는 코드 임베딩이 임베딩 표현 공간에서 더 고르게 분포되어 있다.
- 이는 표현 공간에서 코드 임베딩의 다양한 분포를 달성하기 위한 다양성 정규화의 효과를 검증하고, 코드 할당 편향 문제를 완화한다.

4.3.4 Investigation on Collaborative Signals in Identifiers (RQ2)

목표 : LETTER가 식별자에 협업 신호를 효과적으로 인코딩하는지 확인한다.
방법 : 두 가지 실험을 설계한다.
- 순위 실험 :
  - 아이템의 양자화된 임베딩을 활용하여 상호 작용 예측을 수행하고 LETTER의 순위 성능을 평가한다.
  - 잘 훈련된 기존 CF 모델(SASRec)의 아이템 임베딩을 양자화된 임베딩으로 대체한다.
  - 협업 신호를 효과적으로 캡처하는 식별자는 더 나은 순위 성능을 나타낼 것이다.
- 유사성 실험 :
  - 유사한 협업 신호를 가진 아이템이 유사한 식별자를 나타내는지 확인한다.
  - 사전 훈련된 CF 임베딩의 유사성을 기반으로 각 아이템을 가장 유사한 아이템과 쌍으로 묶는다.
  - 아이템 쌍 내에서 코드 시퀀스의 유사성을 평가한다. (두 아이템의 코드 시퀀스 간 겹침 정도 측정)
결과 :
- 순위 실험 : LETTER가 TIGER보다 훨씬 뛰어난 성능을 보여 협업 신호의 효과적인 통합을 나타낸다.
- 유사성 실험 : LETTER는 TIGER보다 유사한 협업 신호를 가진 아이템에 대해 더 유사한 코드 시퀀스를 달성하여 의미와 협업 유사성 간의 불일치 문제를 완화한다.

4.3.5 Hyper-Parameter Analysis (RQ3)

목표 : LETTER에 도입된 주요 하이퍼파라미터가 성능에 미치는 영향을 분석하여 향후 응용에 도움을 준다.

분석 대상 및 방법

식별자 길이 𝐿 : 𝐿을 2에서 8로 변경하며 성능 변화를 관찰한다.
코드북 크기 𝑁 : 𝑁을 64, 128, 256, 512로 변경하며 성능 변화를 평가한다.
협업 정규화 강도 𝛼 : 𝛼를 0.001에서 0.1로 변경하며 성능 변화를 관찰한다.
다양성 정규화 강도 𝛽 : 𝛽를 0.00001에서 0.01로 조정하며 다양한 강도가 미치는 영향을 조사한다.
클러스터 𝐾 : 𝐾를 5에서 20으로 변경하며 성능 변화를 관찰한다.
온도 𝜏 : 𝜏를 0.6에서 1.2로 변경하며 LETTER-TIGER의 성능 변화를 평가한다.

분석 결과

식별자 길이 𝐿 :
- 𝐿을 2에서 4로 늘리면 성능이 향상된다. 지나치게 짧은 식별자는 세분화된 정보를 잃어 표현력이 약해질 수 있다.
- 𝐿을 4에서 8로 늘리면 성능이 저하된다. 자동 회귀 생성 시 오류 누적으로 어려움을 겪기 때문, 긴 식별자를 정확하게 생성하는 것이 더 어렵다.
코드북 크기 𝑁 :
- 𝑁을 점진적으로 늘리면 성능이 향상되는 경향이 있다. 작은 크기의 코드북은 코드 선택의 제한된 다양성으로 인해 아이템을 효과적으로 구별하지 못할 수 있다.
- 맹목적으로 𝑁을 확장하면 성능이 저하될 수 있다. 큰 코드북 크기는 아이템의 의미 정보에서 노이즈에 더 취약하여 의미 없는 일부 의미에 과적합될 수 있다.
협업 정규화 강도 𝛼 :
- 𝛼가 증가함에 따라 성능의 전체적인 추세는 일반적으로 개선된다. 𝛼가 클수록 협업 패턴의 주입이 강하지만, 지나치게 큰 𝛼는 의미 정규화를 방해할 수 있다.
- 경험적으로 𝛼 = 0.02로 설정하는 것이 좋다. 의미 및 협업 정규화 간의 적절한 균형을 달성하여 최상의 성능을 얻을 수 있다.
다양성 정규화 강도 𝛽 :
- 약간의 강도로 다양성 정규화를 적용하는 것만으로도 코드 할당의 다양성을 향상시키기에 충분하다. 𝛽 = 0.00001에서 𝛽 = 0.0001로 크게 개선
- 과도한 양의 다양성 신호는 의미 및 협업 신호의 토크나이저 통합을 방해할 수 있다.
클러스터 𝐾 :
- 𝐾를 10에서 줄이거나 늘리면 성능이 저하되는 경향이 있다.
- 지나치게 큰 클러스터는 너무 많은 코드 임베딩을 포함하여 동일한 클러스터 내의 임베딩이 충분히 가깝지 않고, 지나치게 작은 클러스터는 상대적으로 적은 코드 임베딩을 가지고 있어 동일한 클러스터 내의 임베딩이 지나치게 가깝기 때문이다.
온도 𝜏 :
- 𝜏를 1.2에서 0.7로 줄이면 성능이 저하되는 경향이 있다.
- 온도를 낮추면 어려운 부정적 샘플에 대한 페널티에 더 많은 강조점을 두어 순위 능력이 강화되어 추천 성능이 향상된다.
- 너무 작은 𝜏는 다른 사용자에 대해 어려운 부정적 샘플이 긍정적 샘플로 간주될 가능성을 억제할 수 있으므로 𝜏를 신중하게 선택해야 한다.

생성적 추천을 위한 LLM (LLMs for Generative Recommendation)

LLM은 생성적 추천에 유망한 전망을 보여주며, 아이템 토큰화는 중요한 문제이다. 아이템 토큰화에 대한 기존 연구는 주로 세 가지 유형의 식별자를 조사한다.

ID 식별자 초기 단계에서 무작위로 할당된 ID는 아이템의 의미 정보 및 협업 패턴을 효과적으로 인코딩하는 데 어려움을 겪는다. SemID 및 CID와 같은 ID 식별자는 아이템 의미 정보 및 협업 신호를 각각 사용하여 식별자를 생성하기 위한 트리와 같은 구조를 구축한다. 그러나 이러한 고정되고 학습할 수 없는 구조는 아이템 유사성을 효율적이고 효과적으로 나타내고 새 아이템에 적응하기 어렵다.
텍스트 식별자 아이템의 자세한 설명 정보를 식별자로 활용한다. 그럼에도 불구하고 이러한 방법은 의미 정보를 계층적으로 인코딩하거나 협업 신호를 통합하는 데 어려움을 겪는다.
코드북 기반 식별자 코드북을 활용하고 훈련 과정에서 의미 정보와 협업 신호를 통합하려고 시도한다. 그러나 협업 신호를 고정된 코드 시퀀스에 통합함으로써 발생하는 불일치와 코드 할당 편향을 간과한다. 특히 LC-Rec는 Sinkhorn-Knopp 알고리즘을 사용하여 반복적인 정규화를 통해 레이어 내 코드를 공정하게 고려하지만 코드 할당의 본질인 코드 임베딩의 분포를 놓친다.

본 연구에서는 계층적 의미와 협업 신호 및 코드 할당 다양성을 통합하는 우수한 식별자를 제안한다.

판별적 추천을 위한 LLM (LLMs for Discriminative Recommendation)

LLM은 생성적 추천뿐만 아니라 다양한 판별적 추천 작업에도 광범위하게 사용된다. 판별적 추천을 위해 LLM을 활용하는 데는 두 가지 주요 접근 방식이 사용된다.

LLM으로 향상된 기존 추천 모델 데이터 증강 및 표현을 위해 LLM을 활용한다.
LLM 기반 추천 모델 LLM을 추천 모델로 직접 활용한다. 순위 지정을 위해 사용자와 아이템 간의 일치 점수를 계산하기 위해 프로젝션 레이어를 통합하거나, 클릭률 (CTR) 예측을 위해 LLM을 활용하여 사용자가 이 아이템을 좋아할지 여부를 결정하기 위해 사용자 및 아이템 기능을 결합한다.

본 연구에서는 주로 생성적 추천을 위한 식별자 설계에 중점을 두므로 판별적 방법과의 심층적인 논의 및 비교는 다루지 않는다.

6. Conclusion and Future Work

본 연구에서는 생성적 추천에서 아이템 토큰화에 필요한 최적의 기능에 대한 철저한 분석을 수행했다.
그 결과 아이템 식별자 내에서 계층적 의미, 협업 신호 및 코드 할당 다양성을 캡처하는 것을 목표로 하는 세 가지 형태의 정규화를 통합하는 학습 가능한 토크나이저인 LETTER를 도입했다.
LETTER를 두 개의 주요 생성적 추천 모델에 적용하고 순위 성능을 향상시키기 위해 순위 기반 생성 Loss를 사용했다.
광범위한 실험을 통해 생성적 추천 모델에서 아이템 토큰화에 대한 LETTER의 우수성을 입증했다.

향후 연구 방향

여러 사용자 행동에서 사용자 선호도를 추론할 수 있도록 생성적 추천 모델을 활성화하기 위해 풍부한 사용자 행동으로 토큰화한다.
LETTER는 개방형 추천을 위해 교차 도메인 아이템을 토큰화할 수 있는 잠재력이 있어 생성적 추천 모델이 사용자 선호도 추론 및 다음 아이템 추천을 위해 다중 도메인 사용자 행동 및 아이템을 활용할 수 있다.
생성적 추천 모델 공간에서 복잡한 자연어 지침 및 아이템 토큰을 사용하여 협업 추론을 달성하기 위해 자연어로 된 사용자 지침과 LETTER로 토큰화된 사용자 상호 작용 기록을 결합하는 것이 유망하다.

[레퍼런스] 코딩테스트

Tue, 08 Apr 2025 09:23:24 GMT

프로그래머스 알고리즘 고득점 Kit

1. 정렬

출제빈도 : 높음 / 평균점수 : 높음

K번째수 - level 1

https://school.programmers.co.kr/learn/courses/30/lessons/42748

def solution(array, commands):
    answer = []
    for com in commands:
        i = com[0]; j = com[1]; k = com[2]
        arr = array[i-1:j]
        arr.sort()
        answer.append(arr[k-1])
    return answer

def solution(array, commands):
    answer = []
    for com in commands:
        i, j, k = com
        answer.append(sorted(array[i-1:j])[k-1])
    return answer

가장 큰 수 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/42746

def solution(numbers):
    answer = ''
    num = list(map(str, numbers))
    num.sort(key=lambda x: x*3, reverse=True)
    answer = ''.join(num)
    answer = str(int(answer))   # [0,0] -> "0"
    return answer

H-Index - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/42747

def solution(citations):
    answer = 0
    n = len(citations)
    citations.sort(reverse=True)
    while n > 0:
        cnt = 0
        for cit in citations:
            if cit >= n:
                cnt += 1
            else:
                break
        if cnt >= n:
            answer = n
            break
        n -= 1
    return answer

2. 해시

출제빈도 : 높음 / 평균점수 : 보통

완주하지 못한 선수 - level 1

https://school.programmers.co.kr/learn/courses/30/lessons/42576

def solution(participant, completion):
    answer = ''
    for comp in completion:
        participant.pop(participant.index(comp))
    answer = participant[0]
    return answer

효율성 테스트 실패 -> 해시 사용

def solution(participant, completion):
    answer = ''
    dic = {}
    for p in participant:
        if p in dic:
            dic[p] += 1
        else:
            dic[p] = 1
    for c in completion:
        dic[c] -= 1
    for key, value in dic.items():
        if value > 0:
            answer = key
            break
    return answer

폰켓몬 - level 1

https://school.programmers.co.kr/learn/courses/30/lessons/1845

def solution(nums):
    answer = 0
    n = len(nums) / 2
    n_type = len(set(nums))
    if n_type >= n:
        answer = n
    else:
        answer = n_type
    return answer

전화번호 목록 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/42577

def solution(phone_book):
    phone_book.sort()
    for i in range(len(phone_book)-1):
        if phone_book[i] == phone_book[i+1][:len(phone_book[i])]:
            return False
    return True

def solution(phone_book):
    dic = {}
    for pb in phone_book:
        dic[pb] = 1
    for pb in phone_book:
        num = ""
        for n in pb:
            num += n
            if num in dic and num != pb:
                return False
    return True

의상 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/42578

def solution(clothes):
    clothes_dict = {}
    for cloth in clothes:
        if cloth[1] not in clothes_dict:
            clothes_dict[cloth[1]] = 1
        else:
            clothes_dict[cloth[1]] += 1
    answer = 1
    for value in clothes_dict.values():
        answer *= (value + 1)    # 해당 의상을 안입는 경우도 포함
    answer -= 1    # 아무것도 안입는 경우 제외
    return answer

베스트앨범 - level 3

3. 완전탐색

출제빈도 : 높음 / 평균점수 : 낮음

최소직사각형 - level 1

https://school.programmers.co.kr/learn/courses/30/lessons/86491

def solution(sizes):
    answer = 0
    w = []; h = []
    for size in sizes:
        w.append(max(size))
        h.append(min(size))
    answer = max(w) * max(h)
    return answer

모의고사 - level 1

https://school.programmers.co.kr/learn/courses/30/lessons/42840 풀이 실패 - 런타임

def solution(answers):
    answer = []
    length = len(answers)
    spj1 = [1,2,3,4,5]
    spj2 = [2,1,2,3,2,4,2,5]
    spj3 = [3,3,1,1,2,2,4,4,5,5]

    n = [0,0,0]
    for i, ans in enumerate(answers):
        if ans == spj1[i%5]:
            n[0] += 1
        if ans == spj2[i%8]:
            n[1] += 1
        if ans == spj3[i%10]:
            n[2] += 1

    if n[0] == max(n):
        answer.append(1)
    if n[1] == max(n):
        answer.append(2)
    if n[2] == max(n):
        answer.append(3)

    return answer

소수 찾기 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/42839 풀이 실패

from itertools import permutations

def is_prime(n):
    if n <= 1:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

def solution(numbers):
    answer = 0
    nums = set()
    for i in range(1, len(numbers)+1):
        for num in permutations(list(numbers), i):
            nums.add(int(''.join(num)))
    for n in nums:
        if is_prime(n) == True:
            answer += 1
    return answer

카펫 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/42842

def solution(brown, yellow):
    answer = []
    # yellow = (w-2)*(h-2), brown = w*2+*(h-2)*2 = 2w+2h-4, w+h=(brown+4)/2
    sum_wh = (brown + 4) / 2
    for h in range(3, int(sum_wh/2)+1):    # h 최소 3
        w = sum_wh - h
        if h * w == brown + yellow:
            answer.append(w)
            answer.append(h)
            break
    return answer

관계식을 세워서 복잡하게 해결

def solution(brown, yellow):
    for i in range(1, yellow+1):    # i는 yellow 높이
        if yellow % i == 0:
            a = yellow / i + 2
            b = i + 2
            if a * b == brown + yellow:
                answer = [a,b]
                break
    return answer

노란색 카펫의 높이를 기준으로 잡으면 쉽게 해결 가능

피로도 - level 2

전력망을 둘로 나누기 - level 2

모음사전 - level 2

4. 깊이/너비 우선 탐색 (DFS/BFS)

출제빈도 : 높음 / 평균점수 : 낮음

타겟 넘버 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/43165

from itertools import combinations

def solution(numbers, target):
    answer = 0
    sum_num = sum(numbers)
    need_minus = int((sum_num - target) / 2)
    for i in range(1, need_minus + 1):
        for com in combinations(numbers, i):
            if sum(com) == need_minus:
                answer += 1
    return answer

def solution(numbers, target):
    answer = 0
    nodes = [0]
    for num in numbers:
        temp = []
        for parent in nodes:
            temp.append(parent + num)
            temp.append(parent - num)
        nodes = temp
    for node in nodes:
        if node == target:
            answer += 1
    return answer

#BFS 풀이
def solution(numbers, target):
    answer = 0
    leaves = [0]
    for num in numbers:
        tmp = []
        for parent in leaves:
            tmp.append(parent + num)
            tmp.append(parent - num)
        leaves = tmp
    for leaf in leaves:
        if leaf == target:
            answer += 1
    return answer

#DFS 풀이
def DFS(numbers, target, depth):
    answer = 0
    if depth == len(numbers):
        print(numbers)
        if sum(numbers) == target:
            return 1
        else: return 0
    else:
        answer += DFS(numbers, target, depth+1)
        numbers[depth] *= -1
        answer += DFS(numbers, target, depth+1)
        return answer

def solution(numbers, target):
    answer = DFS(numbers, target, 0)
    return answer

네트워크 - level 3

게임 맵 최단거리 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/1844

def solution(maps):
    answer = 0
    n = len(maps); m = len(maps[0])
    go_e = [0,1]; go_w = [0,-1]; go_s = [1,0]; go_n = [-1,0]
    leaves = [[1,1]]
    for i in range(2, n*m+1):
        temp = []
        for parent in leaves: 
            for go in [go_e, go_w, go_s, go_n]:
                gone = [x+y for x,y in zip(parent, go)]
                # 도착
                if gone[0] == n and gone[1] == m:
                    answer = i
                    return answer
                # 막힌 경우는 제외하기
                if (gone[0] == 0 or n+1) or (gone[1] == 0 or m+1):
                    continue
                elif maps[gone[0]][gone[1]] == 0:
                    continue
                else:
                    temp.append(gone)
        leaves = temp
        if leaves == []:
            answer = -1
            break
    return answer

def solution(maps):
    answer = 0
    n = len(maps); m = len(maps[0])
    dx = [1, -1, 0, 0]    # 남,북,동,서
    dy = [0, 0, 1, -1]
    nodes = [[1, 1]]
    for i in range(2, n*m+1):    # 최대 n*m번 이동
        temp = []
        for parent in nodes:
            for x, y in zip(dx,dy):
                child = [parent[0] + x, parent[1] + y]
                if child == [n, m]:    # 목적지에 도착한 경우
                    answer = i
                    return answer
                if not (1 <= child[0] <= n and 1 <= child[1] <= m):    # 맵을 이탈한 경우
                    continue
                if maps[child[0]-1][child[1]-1] == 0:    # 벽에 막힌 경우
                    continue
                temp.append(child)
        if len(temp) > 0:    # 갈수있는 길이 있는 경우
            nodes = temp
        else:
            answer = -1
    answer = -1
    return answer

효율성 테스트 실패

단어 변환 - level 3

아이템 줍기 - level 3

여행경로 - level 3

퍼즐 조각 채우기 - level 3

5. 스택/큐

출제빈도 : 보통 / 평균점수 : 높음

같은 숫자는 싫어 - level 1

https://school.programmers.co.kr/learn/courses/30/lessons/12906

def solution(arr):
    answer = []
    past = -1
    for a in arr:
        if a == past:
            continue
        else:
            answer.append(a)
            past = a
    return answer

기능개발 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/42586

def solution(progresses, speeds):
    answer = []
    while progresses:    # 리스트가 빌 때까지 반복
        progresses = [x+y for x,y in zip(progresses, speeds)]
        n = 0
        while progresses and progresses[0] >= 100:
            n += 1
            progresses.pop(0)
            speeds.pop(0)
        if n != 0:
            answer.append(n)
    return answer

올바른 괄호 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/12909

def solution(s):
    answer = True
    test = 0
    for tmp in s:
        if tmp == '(':
            test += 1
        else:
            test -= 1
        if test < 0:
            break
    if test != 0:
        answer = False
    return answer

# Stack 활용
def solution(s):
    answer = True
    stack = []
    for i in s:
        if i == '(':    # 왼쪽 괄호 stack에 보관
            stack.append(i)
        elif i == ')':    # stack의 왼쪽 괄호 한개 제거
            if stack:
                stack.pop()
            else:    # stack에 왼쪽 괄호가 없는데 오른쪽 괄호가 나오면 안됨
                return False
    if stack:    # 마지막에 stack이 비어야함
        return False
    else:
        return True

프로세스 - level 2

다리를 지나는 트럭 - level 2

주식가격 - level 2

6. 힙 (Heap)

출제빈도 : 보통 / 평균점수 : 높음

더 맵게 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/42626

def solution(scoville, K):
    answer = 0
    while 1:
        # 최소 스코빌이 K보다 작은데 음식이 부족한 경우
        if len(scoville) < 2 and scoville[0] < K:
            answer = -1
            break
        # 최소 스코빌이 K보다 큰 경우
        scoville.sort()
        if scoville[0] >= K:
            break
        # 새로운 음식 만들기
        new_s = scoville[0] + (scoville[1] * 2)
        scoville = scoville[2:]
        scoville.append(new_s)
        answer += 1
    return answer

효율성 테스트 실패 -> 힙 활용

# Heap 활용
# heapq.heapify(arr) : 리스트를 heap으로 변환
# heapq.heappop(arr) : heap에서 가장 작은 수 리턴
# heapq.heappush(arr, item) : heap에 삽입

import heapq
def solution(scoville, K):
    answer = 0
    heapq.heapify(scoville)

    while scoville[0] < K:
        if len(scoville) == 1:
            return -1
        mix = heapq.heappop(scoville) + (heapq.heappop(scoville) * 2)
        heapq.heappush(scoville, mix)
        answer += 1
    return answer

디스크 컨트롤러 - level 3

이중우선순위큐 - level 3

7. 탐욕법 (Greedy)

출제빈도 : 낮음 / 평균점수 : 낮음

체육복 - level 1

https://school.programmers.co.kr/learn/courses/30/lessons/42862

def solution(n, lost, reserve):
    lost_d = list(set(lost) - set(reserve))
    reserve_d = list(set(reserve) - set(lost))
    answer = n - len(lost_d)
    for l in lost_d:
        if l-1 in reserve_d:
            answer += 1
            reserve_d.remove(l-1)
        elif l+1 in reserve_d:
            answer += 1
            reserve_d.remove(l+1)
    return answer

조이스틱 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/42860 풀이 실패

def solution(name):

    # 알파벳 변경 횟수 (상하 이동) 
    spell_move = 0

    # 커서 이동 횟수, 이름의 길이 - 1 (좌우 이동)
    cursor_move = len(name) - 1  


    for i, spell in enumerate(name):
        # 알파벳 변경 횟수, 위아래 중 최소 이동 값 (상하 이동)
        spell_move += min(ord(spell) - ord('A'), ord('Z') - ord(spell) + 1)

        # 해당 알파벳 다음부터 연속된 A 문자열 찾기
        next = i + 1
        while next < len(name) and name[next] == 'A':
            next += 1

        # 아래 3가지 경우 중 최소 이동 값으로 갱신
        # 1. 이전 커서 이동 값 (초기값 : 이름의 길이 - 1)
        # 2. 연속된 A의 왼쪽 시작
        # 3. 연속된 A의 오른쪽 시작
        cursor_move = min([ cursor_move, 2 * i + len(name) - next, i + 2 * (len(name) - next) ])


    # 조이스틱 조작 횟수 = 알파벳 변경 횟수(상하 이동) + 커서 이동 횟수(좌우 이동)    
    return spell_move + cursor_move

'''
A까지 이동시킨 후에 맨 뒤로 돌아가서 커서를 왼쪽으로 이동시키는 방법
- i까지 이동한 상태에서 ( i ) , 뒤이어 나올 A의 개수를 세어준다. (nextIndex = 연속된 A의 마지막 인덱스)
- 다시 맨 처음으로 돌아가 ( + i )
- 맨 끝에서부터 A가 나오기 전까지 이동시킨다 ( + len - nextIndex )
- 총 이동 = i + i + len - nextIndex

처음부터 맨뒤에서 시작한 후에 다시 맨 앞으로 돌아오는 방법
- 맨 끝부터 시작해서 A가 나오기 전까지 이동한다 ( len - nextIndex )
- 다시 맨 앞으로 돌아온다. ( + len - nextIndex )
- A가 나올 때까지 오른쪽으로 이동시키기 ( i )
- 총 이동 = len - nextIndex * 2 + i
'''

해설 1 : https://aiday.tistory.com/120 해설 2 : https://whynotworking.tistory.com/entry/%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%A8%B8%EC%8A%A4python-%EC%A1%B0%EC%9D%B4%EC%8A%A4%ED%8B%B1

큰 수 만들기 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/42883

def solution(number, k):
    answer = ''
    # 앞자릿수 최대 만들기
    f_num = number[:k+1]
    f_num = list(map(int, list(f_num)))    # 숫자 리스트로
    cut = f_num.index(max(f_num))    # 최대 앞자릿수 인덱스
    number = number[cut:]    # 인덱스로 자르기
    k -= cut

    # 뒤의 숫자보다 작으면 삭제
    if k > 0:
        count_k = k
        number = list(map(int, list(number)))    # 숫자 리스트로
        for i in range(k):
            for j in range(len(number)):
                if number[j] < number[j+1]:
                    number.pop(j)
                    count_k -= 1
                    break
        if count_k > 0:    # 삭제 안되고 남은 횟수
            number = number[:-count_k]    # 남은 횟수만큼 맨뒤 숫자 삭제
        number = ''.join(list(map(str, number)))    # 문자열로
    else:
        pass
    answer = number
    return answer

효율성 테스트 실패

def solution(number, k):
    # 뒤의 숫자보다 작으면 삭제
    count_k = k
    number = list(map(int, list(number)))    # 숫자 리스트로
    for i in range(k):
        for j in range(len(number)):
            if number[j] < number[j+1]:
                number.pop(j)
                count_k -= 1
                break
    if count_k > 0:    # 삭제 안되고 남은 횟수
        number = number[:-count_k]    # 남은 횟수만큼 맨뒤 숫자 삭제
    number = ''.join(list(map(str, number)))    # 문자열로
    return number

앞 부분이 필요 없었음 점수는 약간 올랐지만 효율성 테스트 실패 한 번 삭제하면 다시 처음부터 검사해서 효율이 안좋음 스택으로 푸는게 더 효율적

def solution(number, k):
    # 스택 선언
    stack = []

    # number의 길이만큼 for loop
    for num in number:
        # 1. 제거할 수 k가 남았고
        # 2. 스택에 값이 있고
        # 3. 스택의 마지막 값이 num보다 작다면
        # 제거 후 제거할 수 k를 1씩 감소 
        while k > 0 and stack and stack[-1] < num:
            stack.pop()
            k -= 1
        # 스택에 num 추가
        stack.append(num)

    # k가 남아있는 경우 - 테스트 케이스 number: "93939", k: 2, 출력: 999, 실제정답: 99
    if k != 0:
        stack = stack[:-k]

    # 배열을 문자열로 바꿔주고 반환
    return ''.join(stack)

해설 : https://aiday.tistory.com/116

구명보트 - level 2

섬 연결하기 - level 3

단속카메라 - level 3

8. 동적계획법 (Dynamic Programming)

출제빈도 : 낮음 / 평균점수 : 낮음

N으로 표현 - level 3

정수 삼각형 - level 3

등굣길 - level 3

사칙연산 - level 4

도둑질 - level 4

9. 이분탐색

출제빈도 : 낮음 / 평균점수 : 낮음

입국심사 - level 3

징검다리 - level 4

10. 그래프

출제빈도 : 낮음 / 평균점수 : 낮음

가장 먼 노드 - level 3

순위 - level 3

방의 개수 - level 5

프로그래머스 SQL 고득점 Kit

1. SELECT

출제빈도 : 낮음 / 평균점수 : 높음

조건에 부합하는 중고거래 댓글 조회하기 - level 1

https://school.programmers.co.kr/learn/courses/30/lessons/164673

SELECT B.TITLE
     , B.BOARD_ID
     , R.REPLY_ID
     , R.WRITER_ID
     , R.CONTENTS
     , DATE_FORMAT(R.CREATED_DATE, '%Y-%m-%d') AS CREATED_DATE
FROM USED_GOODS_BOARD AS B
JOIN USED_GOODS_REPLY AS R
    ON B.BOARD_ID = R.BOARD_ID
WHERE DATE_FORMAT(B.CREATED_DATE, '%Y-%m') = '2022-10'
ORDER BY R.CREATED_DATE, B.TITLE

과일로 만든 아이스크림 고르기 - level 1

https://school.programmers.co.kr/learn/courses/30/lessons/133025

SELECT F.FLAVOR
FROM FIRST_HALF AS F
JOIN ICECREAM_INFO AS I
    ON F.FLAVOR = I.FLAVOR
WHERE F.TOTAL_ORDER > 3000
    AND I.INGREDIENT_TYPE = 'fruit_based'
ORDER BY F.TOTAL_ORDER DESC

3월에 태어난 여성 회원 목록 출력하기 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/131120

SELECT MEMBER_ID
     , MEMBER_NAME
     , GENDER
     , DATE_FORMAT(DATE_OF_BIRTH, '%Y-%m-%d') AS DATE_OF_BIRTH
FROM MEMBER_PROFILE
WHERE DATE_FORMAT(DATE_OF_BIRTH, '%m') = 3
     AND GENDER = 'W'
     AND TLNO IS NOT NULL
ORDER BY MEMBER_ID

WHERE MONTH(DATE_OF_BIRTH) = 3

재구매가 일어난 상품과 회원 리스트 구하기 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/131536

SELECT USER_ID
     , PRODUCT_ID
FROM ONLINE_SALE
GROUP BY USER_ID, PRODUCT_ID
HAVING COUNT(*) > 1
ORDER BY USER_ID, PRODUCT_ID DESC

2. SUM, MAX, MIN

출제빈도 : 보통 / 평균점수 : 높음

가장 비싼 상품 구하기 - level 1

https://school.programmers.co.kr/learn/courses/30/lessons/131697

SELECT MAX(PRICE) AS MAX_PRICE
FROM PRODUCT

최댓값 구하기 - level 1

https://school.programmers.co.kr/learn/courses/30/lessons/59415

SELECT MAX(DATETIME) AS 시간
FROM ANIMAL_INS

가격이 제일 비싼 식품의 정보 출력하기 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/131115

SELECT PRODUCT_ID
     , PRODUCT_NAME
     , PRODUCT_CD
     , CATEGORY
     , MAX(PRICE) AS PRICE
FROM FOOD_PRODUCT

이렇게 실행하면 PRICE만 최댓값이 나오고 나머지 열은 첫번째 행이 나온다.

SELECT *
FROM FOOD_PRODUCT
WHERE PRICE = (SELECT MAX(PRICE) FROM FOOD_PRODUCT)

SELECT *
FROM FOOD_PRODUCT
ORDER BY PRICE DESC
LIMIT 1

최솟값 구하기 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/59038

SELECT DATETIME AS 시간
FROM ANIMAL_INS
WHERE DATETIME = (SELECT MIN(DATETIME) FROM ANIMAL_INS)

SELECT DATETIME AS 시간
FROM ANIMAL_INS
ORDER BY DATETIME
LIMIT 1

SELECT MIN(DATETIME) AS 시간
FROM ANIMAL_INS

이 문제는 최솟값만 조회하므로 이렇게 써도된다.

동물 수 구하기 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/59406

SELECT COUNT(*) AS count
FROM ANIMAL_INS

중복 제거하기 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/59408

SELECT COUNT(DISTINCT NAME) AS count
FROM ANIMAL_INS
WHERE NAME IS NOT NULL
;

3. GROUP BY

출제빈도 : 보통 / 평균점수 : 보통

진료과별 총 예약 횟수 출력하기 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/132202

SELECT MCDP_CD AS 진료과코드
     , COUNT(*) AS 5월예약건수
FROM APPOINTMENT
WHERE DATE_FORMAT(APNT_YMD, '%Y-%m') = '2022-05'
GROUP BY MCDP_CD
ORDER BY 5월예약건수, 진료과코드

성분으로 구분한 아이스크림 총 주문량 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/133026

SELECT INGREDIENT_TYPE
     , SUM(TOTAL_ORDER) AS TOTAL_ORDER
FROM FIRST_HALF AS F
JOIN ICECREAM_INFO AS I
    ON F.FLAVOR = I.FLAVOR
GROUP BY INGREDIENT_TYPE
ORDER BY TOTAL_ORDER

자동차 종류 별 특정 옵션이 포함된 자동차 수 구하기 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/151137

SELECT CAR_TYPE
     , COUNT(*) AS CARS
FROM CAR_RENTAL_COMPANY_CAR
WHERE OPTIONS LIKE '%통풍시트%'
    OR OPTIONS LIKE '%열선시트%'
    OR OPTIONS LIKE '%가죽시트%'
GROUP BY CAR_TYPE
ORDER BY CAR_TYPE

입양 시각 구하기(1) - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/59412

SELECT HOUR(DATETIME) AS HOUR
     , COUNT(*) AS COUNT
FROM ANIMAL_OUTS
WHERE HOUR(DATETIME) BETWEEN 9 AND 19
GROUP BY HOUR(DATETIME)
ORDER BY HOUR
;

가격대 별 상품 개수 구하기 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/131530

SELECT FLOOR(PRICE / 10000) * 10000 AS PRICE_GROUP
     , COUNT(*) AS PRODUCTS
FROM PRODUCT
GROUP BY PRICE_GROUP
ORDER BY PRICE_GROUP
;

4. IS NULL

출제빈도 : 낮음 / 평균점수 : 보통

경기도에 위치한 식품창고 목록 출력하기 - level 1

https://school.programmers.co.kr/learn/courses/30/lessons/131114

SELECT WAREHOUSE_ID
     , WAREHOUSE_NAME
     , ADDRESS
     , IFNULL(FREEZER_YN, 'N')
FROM FOOD_WAREHOUSE
WHERE ADDRESS LIKE '경기도%'
ORDER BY WAREHOUSE_ID

이름이 없는 동물의 아이디 - level 1

https://school.programmers.co.kr/learn/courses/30/lessons/59039

SELECT ANIMAL_ID
FROM ANIMAL_INS
WHERE ISNULL(NAME) = TRUE
ORDER BY ANIMAL_ID

WHERE NAME IS NULL

NULL 처리하기 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/59410

SELECT ANIMAL_TYPE
     , IFNULL(NAME, 'No name') AS NAME
     , SEX_UPON_INTAKE
FROM ANIMAL_INS
ORDER BY ANIMAL_ID

ROOT 아이템 구하기 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/273710

SELECT I.ITEM_ID
     , I.ITEM_NAME
FROM ITEM_INFO AS I
JOIN ITEM_TREE AS T
    ON I.ITEM_ID = T.ITEM_ID
WHERE T.PARENT_ITEM_ID IS NULL
ORDER BY ITEM_ID

5. JOIN

출제빈도 : 높음 / 평균점수 : 낮음

조건에 맞는 도서와 저자 리스트 출력하기 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/144854

SELECT B.BOOK_ID
     , A.AUTHOR_NAME
     , DATE_FORMAT(B.PUBLISHED_DATE, '%Y-%m-%d') AS PUBLISHED_DATE
FROM BOOK AS B
JOIN AUTHOR AS A
    ON B.AUTHOR_ID = A.AUTHOR_ID
WHERE B.CATEGORY = '경제'
ORDER BY PUBLISHED_DATE

상품 별 오프라인 매출 구하기 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/131533

SELECT P.PRODUCT_CODE
     , SUM(P.PRICE * S.SALES_AMOUNT) AS SALES
FROM PRODUCT AS P
JOIN OFFLINE_SALE AS S
    ON P.PRODUCT_ID = S.PRODUCT_ID
GROUP BY P.PRODUCT_CODE
ORDER BY SALES DESC, PRODUCT_CODE
;

없어진 기록 찾기 - level 3

https://school.programmers.co.kr/learn/courses/30/lessons/59042

SELECT O.ANIMAL_ID
     , O.NAME
FROM ANIMAL_OUTS AS O
LEFT JOIN ANIMAL_INS AS I
    ON O.ANIMAL_ID = I.ANIMAL_ID
WHERE I.ANIMAL_ID IS NULL
ORDER BY O.ANIMAL_ID

있었는데요 없었습니다 - level 3

https://school.programmers.co.kr/learn/courses/30/lessons/59043

SELECT I.ANIMAL_ID
     , I.NAME
FROM ANIMAL_INS AS I
JOIN ANIMAL_OUTS AS O
    ON I.ANIMAL_ID = O.ANIMAL_ID
WHERE I.DATETIME > O.DATETIME
ORDER BY I.DATETIME

주문량이 많은 아이스크림들 조회하기 - level 4

https://school.programmers.co.kr/learn/courses/30/lessons/133027

SELECT F.FLAVOR
FROM FIRST_HALF AS F
JOIN JULY AS J
    ON F.FLAVOR = J.FLAVOR
GROUP BY F.FLAVOR
ORDER BY SUM(F.TOTAL_ORDER) + SUM(J.TOTAL_ORDER) DESC
LIMIT 3;

SELECT U.FLAVOR
FROM (SELECT * FROM FIRST_HALF
      UNION
      SELECT * FROM JULY) AS U
GROUP BY U.FLAVOR
ORDER BY SUM(U.TOTAL_ORDER) DESC
LIMIT 3;

SELECT F.FLAVOR
FROM FIRST_HALF AS F
JOIN (SELECT FLAVOR, SUM(TOTAL_ORDER) AS TOTAL_ORDER
      FROM JULY
      GROUP BY FLAVOR) AS J
    ON F.FLAVOR = J.FLAVOR
ORDER BY F.TOTAL_ORDER + J.TOTAL_ORDER DESC
LIMIT 3;

6. String, Date

출제빈도 : 낮음 / 평균점수 : 낮음

특정 옵션이 포함된 자동차 리스트 구하기 - level 1

https://school.programmers.co.kr/learn/courses/30/lessons/157343

SELECT *
FROM CAR_RENTAL_COMPANY_CAR
WHERE OPTIONS LIKE '%네비게이션%'
ORDER BY CAR_ID DESC

자동차 대여 기록에서 장기/단기 대여 구분하기 - level 1

https://school.programmers.co.kr/learn/courses/30/lessons/151138

SELECT HISTORY_ID
     , CAR_ID
     , DATE_FORMAT(START_DATE, '%Y-%m-%d') AS START_DATE
     , DATE_FORMAT(END_DATE, '%Y-%m-%d') AS END_DATE
     , CASE WHEN DATEDIFF(END_DATE, START_DATE) + 1 >= 30 THEN '장기 대여'
            ELSE '단기 대여'
            END AS RENT_TYPE
FROM CAR_RENTAL_COMPANY_RENTAL_HISTORY
WHERE DATE_FORMAT(START_DATE, '%Y-%m') = '2022-09'
ORDER BY HISTORY_ID DESC

자동차 평균 대여 기간 구하기 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/157342

SELECT CAR_ID
     , ROUND(AVG(DATEDIFF(END_DATE, START_DATE) + 1), 1) AS AVERAGE_DURATION
FROM CAR_RENTAL_COMPANY_RENTAL_HISTORY
GROUP BY CAR_ID
HAVING AVERAGE_DURATION >= 7
ORDER BY AVERAGE_DURATION DESC, CAR_ID DESC

조건에 부합하는 중고거래 상태 조회하기 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/164672

SELECT BOARD_ID
     , WRITER_ID
     , TITLE
     , PRICE
     , CASE STATUS
        WHEN 'SALE' THEN '판매중'
        WHEN 'DONE' THEN '거래완료'
        WHEN 'RESERVED' THEN '예약중'
        END AS STATUS
FROM USED_GOODS_BOARD
WHERE DATE_FORMAT(CREATED_DATE, '%Y-%m-%d') = '2022-10-05'
ORDER BY BOARD_ID DESC

중성화 여부 파악하기 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/59409

     , NAME
     , CASE
       WHEN SEX_UPON_INTAKE LIKE '%Neutered%'
           OR SEX_UPON_INTAKE LIKE '%Spayed%' THEN 'O'
       ELSE 'X'
       END AS '중성화'
FROM ANIMAL_INS
;

카테고리 별 상품 개수 구하기 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/131529

SELECT SUBSTR(PRODUCT_CODE, 1, 2) AS CATEGORY
     , COUNT(*) AS PRODUCTS
FROM PRODUCT
GROUP BY SUBSTR(PRODUCT_CODE, 1, 2)
ORDER BY CATEGORY
;

Hacker Rank Algorithm

Easy

Plus Minus

https://www.hackerrank.com/challenges/one-week-preparation-kit-plus-minus/problem?isFullScreen=true&h_l=interview&playlist_slugs%5B%5D=preparation-kits&playlist_slugs%5B%5D=one-week-preparation-kit&playlist_slugs%5B%5D=one-week-day-one

def plusMinus(arr):
    n_pos = 0; n_neg = 0; n_zero = 0
    n = len(arr)

    for num in arr:
        if num > 0:
            n_pos += 1
        elif num < 0:
            n_neg += 1
        else:
            n_zero += 1

    answer_pos = n_pos / n
    answer_neg = n_neg / n
    answer_zero = n_zero / n

    print(f'{answer_pos:.6f}')
    print(f'{answer_neg:.6f}')
    print(f'{answer_zero:.6f}')

if __name__ == '__main__':
    n = int(input().strip())
    arr = list(map(int, input().rstrip().split()))
    plusMinus(arr)

Mini-Max Sum

https://www.hackerrank.com/challenges/one-week-preparation-kit-mini-max-sum/problem?isFullScreen=true&h_l=interview&playlist_slugs%5B%5D=preparation-kits&playlist_slugs%5B%5D=one-week-preparation-kit&playlist_slugs%5B%5D=one-week-day-one

def miniMaxSum(arr):
    arr.sort()

    arr_min = arr[:-1]
    arr_max = arr[1:]

    answer_min = sum(arr_min)
    answer_max = sum(arr_max)

    print(f'{answer_min} {answer_max}')

if __name__ == '__main__':
    arr = list(map(int, input().rstrip().split()))
    miniMaxSum(arr)

Time Conversion

https://www.hackerrank.com/challenges/one-week-preparation-kit-time-conversion/problem?isFullScreen=true&h_l=interview&playlist_slugs%5B%5D=preparation-kits&playlist_slugs%5B%5D=one-week-preparation-kit&playlist_slugs%5B%5D=one-week-day-one

def timeConversion(s):
    hour = s[:2]
    ampm = s[-2:]

    if s[:2] == '12':
        if ampm == 'AM':
            hour = str(int(hour) - 12)    # AM 12 to 0
        else:
            pass    # PM 12 to 12
    else:
        if ampm == 'AM':
            pass    # AM 1 to 1
        else:
            hour = str(int(hour) + 12)    # PM 1 to 13

    if len(hour) == 1:    # '0' to '00'
        hour = '0' + hour
    answer = hour + s[2:-2]

    return answer

if __name__ == '__main__':
    fptr = open(os.environ['OUTPUT_PATH'], 'w')
    s = input()
    result = timeConversion(s)
    fptr.write(result + '\n')
    fptr.close()

Lonely Integer

https://www.hackerrank.com/challenges/one-week-preparation-kit-lonely-integer/problem?isFullScreen=true&h_l=interview&playlist_slugs%5B%5D=preparation-kits&playlist_slugs%5B%5D=one-week-preparation-kit&playlist_slugs%5B%5D=one-week-day-two

import os

def lonelyinteger(a):
    if len(a) == 1:    # when list has only one element
        return a[0]

    a.sort()
    tmp = -1
    for i in a:
        if tmp == -1:
            tmp = i
        elif tmp != i:
            return tmp
        else:
            tmp = -1
    return tmp    # when last number is target

if __name__ == '__main__':
    fptr = open(os.environ['OUTPUT_PATH'], 'w')
    n = int(input().strip())
    a = list(map(int, input().rstrip().split()))
    result = lonelyinteger(a)
    fptr.write(str(result) + '\n')
    fptr.close()

Diagonal Difference

https://www.hackerrank.com/challenges/one-week-preparation-kit-diagonal-difference/problem?isFullScreen=true&h_l=interview&playlist_slugs%5B%5D=preparation-kits&playlist_slugs%5B%5D=one-week-preparation-kit&playlist_slugs%5B%5D=one-week-day-two

import os

def diagonalDifference(arr):
    l_to_r = 0
    r_to_l = 0
    index_lr = 0
    index_rl = len(arr) - 1

    for a in arr:
        l_to_r += a[index_lr]
        r_to_l += a[index_rl]
        index_lr += 1
        index_rl -= 1

    return abs((l_to_r - r_to_l))

if __name__ == '__main__':
    fptr = open(os.environ['OUTPUT_PATH'], 'w')
    n = int(input().strip())
    arr = []
    for _ in range(n):
        arr.append(list(map(int, input().rstrip().split())))
    result = diagonalDifference(arr)
    fptr.write(str(result) + '\n')
    fptr.close()

Intermediate

Balanced Brackets

https://www.hackerrank.com/challenges/one-week-preparation-kit-balanced-brackets/problem?isFullScreen=true&h_l=interview&playlist_slugs%5B%5D=preparation-kits&playlist_slugs%5B%5D=one-week-preparation-kit&playlist_slugs%5B%5D=one-week-day-five

import os

def isBalanced(s):
    stack = []
    for char in s:
        if char in ['(', '{', '[']:
            stack.append(char)
        else:
            if not stack:    # when stack emptied
                return 'NO'
            elif char == ')' and stack[-1] == '(':
                stack.pop()
            elif char == '}' and stack[-1] == '{':
                stack.pop()
            elif char == ']' and stack[-1] == '[':
                stack.pop()
            else:
                return 'NO'

    if len(stack) == 0:
        return 'YES'
    else:
        return 'NO'

if __name__ == '__main__':
    fptr = open(os.environ['OUTPUT_PATH'], 'w')
    t = int(input().strip())
    for t_itr in range(t):
        s = input()
        result = isBalanced(s)
        fptr.write(result + '\n')
    fptr.close()

Hacker Rank SQL

Easy

Revising the Select Query I

https://www.hackerrank.com/challenges/revising-the-select-query/problem?isFullScreen=true

SELECT *
FROM CITY
WHERE POPULATION > 100000
    AND COUNTRYCODE = 'USA';

Revising the Select Query II

https://www.hackerrank.com/challenges/revising-the-select-query-2/problem?isFullScreen=true

SELECT NAME
FROM CITY
WHERE COUNTRYCODE = 'USA'
    AND POPULATION > 120000;

Select All

https://www.hackerrank.com/challenges/select-all-sql/problem?isFullScreen=true

SELECT *
FROM CITY;

Intermediate

The PADS

https://www.hackerrank.com/challenges/the-pads/problem?isFullScreen=true

SELECT CONCAT(Name, "(", SUBSTRING(Occupation, 1, 1), ")")
FROM OCCUPATIONS
ORDER BY Name;

SELECT CONCAT("There are a total of ", COUNT(*), " ", LOWER(Occupation), "s.")
FROM OCCUPATIONS
GROUP BY Occupation
ORDER BY COUNT(*), Occupation;

Weather Observation Station 5

https://www.hackerrank.com/challenges/weather-observation-station-5/problem?isFullScreen=true

SELECT CITY
     , CHAR_LENGTH(CITY)
FROM STATION
ORDER BY CHAR_LENGTH(CITY), CITY
LIMIT 1;

SELECT CITY
    , CHAR_LENGTH(CITY)
FROM STATION
ORDER BY CHAR_LENGTH(CITY) DESC, CITY
LIMIT 1;

Binary Tree Nodes

https://www.hackerrank.com/challenges/binary-search-tree-1/problem?isFullScreen=true

SELECT N
     , CASE
       WHEN P IS NULL THEN 'Root'
       WHEN N IN (SELECT DISTINCT P FROM BST) THEN 'Inner'
       ELSE 'Leaf'
       END
FROM BST
ORDER BY N;

프로그래머스 문제 풀이 전략

1. 배열

삼각 달팽이 - level 2

거리두기 확인하기 - level 2

2. 문자열

튜플 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/64065

def solution(s):
    s = eval(s.replace('{','[').replace('}',']'))
    order = []
    for l in s:
        order.append(len(l)-1)
    answer = [0]*len(s)
    for i,o in enumerate(order):
        n = order.index(i)
        answer[i] = list(set(s[n]) - set(answer))[0]
    return answer

이진 변환 반복하기 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/70129

def solution(s):
    n_trans = 0
    n_zero = 0
    while s != '1':
        if '0' in s:
            n_zero += s.count('0')
            s = s.replace('0','')
        s = str(bin(len(s))[2:])
        n_trans += 1
    answer = [n_trans, n_zero]
    return answer

3. 재귀

하노이의 탑 - level 3

모음 사전 - level 2

호텔 방 배정 - level 4

4. 완전 탐색

카펫 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/42842

def solution(brown, yellow):
    for i in range(1, yellow+1):
        if yellow % i == 0:
            a = yellow/i+2; b = i+2
            if a * b - yellow == brown:
                answer = [a,b]
                break
    return answer

불량 사용자 - level 3

수식 최대화 - level 2

5. 정렬

H-index - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/42747

def solution(citations):
    answer = 0
    for h in range(max(citations),0,-1):
        paper = 0
        for i in range(len(citations)):
            if citations[i] >= h:
                paper += 1
        if paper >= h:
            answer = h
            break
    return answer

6. 이진 탐색

입국심사 - level 3

순위 검색 - level 2

징검다리 건너기 - level 3

7. 해시

의상 - level 2

https://school.programmers.co.kr/learn/courses/30/lessons/42578

def solution(clothes):
    dict_clothes = {}
    for cloth in clothes:
        if cloth[1] not in dict_clothes:
            dict_clothes[cloth[1]] = [cloth[0]]
        else:
            dict_clothes[cloth[1]].append(cloth[0])
    answer = 1
    for value in dict_clothes.values():
        answer *= (len(value) + 1)
    answer -= 1
    return answer

베스트 앨범 - level 3

8. 동적 프로그래밍

정수 삼각형 - level 3

등굣길 - level 3

도둑질 - level 4

9. 스택과 큐

주식 가격 - level 2

기능 개발 - level 2

10. 그래프와 트리

가장 먼 노드 - level 3

순위 - level 3

길 찾기 게임 - level 3

11. 자료 구조

디스크 컨트롤러 - level 3

보석 쇼핑 - level 3

섬 연결하기 - level 3

가사 검색 - level 4

12. 구현

2개 이하로 다른 비트 - level 2

줄 서는 방법 - level 2

13. 구현 - 완전 탐색

여행 경로 - level 3

네트워크 - level 3

단어 변환 - level 3

게임 맵 최단거리 - level 3

경주로 건설 - level 3

14. 탐욕 알고리즘

조이스틱 - level 2

큰 수 만들기 - level 2

구명보트 - level 2

단속 카메라 - level 3

함수 정리

isalpha / isdigit

text.isalpha()    # 알파벳인지 확인
text.isdigit()    # 숫자인지 확인
text.isalnum()    # 알파벳 or 숫자인지 확인

int / float / str / list

int(3.14)    # 정수로 변환
> 3

float(3)    # 실수로 변환
> 3.0

str(3.14)    # 문자열로 변환
> "3.14"

list("3.14")    # 리스트로 변환
> ["3",".","1","4"]

나눗셈 / 몫 / 나머지

5 / 2    # 나눗셈
> 2.5
5 // 2    # 몫
> 2
5 % 2    # 나머지
> 1

pow / sqrt / log

import math

2**3    # 거듭 제곱
> 8
pow(2,3)
> 8
math.pow(2,3)
> 8.0

8**(1/2)    # 제곱근
> 2.0
8**(0.5)
> 2.0
math.sqrt(2)
> 2.0

math.log2(8)    # 밑이 2, 10, e인 로그함수
> 3.0
math.log10(100)
> 2.0
math.log(math.e)
> 1.0
math.log(25, 5)    # math.log(a, b) : 밑이 b인 로그함수
> 2.0

map

여러 개의 데이터를 받아서 각각의 요소에 함수를 적용한 결과를 반환

map(str, [1,2,3])
> 
list(map(str, [1,2,3]))
> ["1", "2", "3"]

def square(x):
    return x**2
list(map(square, [1, 2, 3]))
> [1, 4, 9, 16, 25]

리스트에서 여러 변수로 할당

i, j, k = [1, 2, 3]

sort / sorted

num_list.sort()
num_list = sorted(num_list)

# 두번째 원소를 기준으로 정렬
num_str_list.sort(key=lambda x: x[1], reverse=True)

join

''.join(['a', 'b', 'c'])
> 'abc'

index

[4, 5, 6].index(4)
> 0

pop / remove

num_list = [1, 2, 3, 4]

num_list.pop()
> [1, 2, 3]
num_list.pop(2)
> [1, 2, 4]

num_list.remove(3)
> [1, 2, 4]

removed_list = num_list.remove(3)
type(removed_list)
> NoneType

dictionary 반복문

for key, value in dic.items():

for key in dic.keys():

for value in dic.values():

set

set([1, 1, 2, 3])
> {1, 2, 3}

# 교집합, 합집합, 차집합
set1 = set([1, 2, 3, 4])
set2 = set([3, 4, 5, 6])
set1 & set2
> {3, 4}
set1 | set2
> {1, 2, 3, 4, 5, 6}
set1 - set2
> {1, 2}

# 집합에 원소 추가
set1.add(5)
> {1, 2, 3, 4, 5}

# 빈 집합 만들기
empty_set = set()
type(empty_set)
> set
empty_set = {}
type(empty_set)
> dict

zip - 리스트 원소끼리 더하기

[x+y for x,y in zip(list1, list2)]

enumerate

for i, value in enumerate([1,2,3]):
    print(i, value)
> 0 1
  1 2
  2 3

ord / chr - 아스키코드

ord('A')
> 65
ord('Z')
> 90
ord('a')
> 97

chr(65)
> 'A'

# A에서 두 번째 후의 숫자
chr(ord('A') + 2)
> 'C'

# 알파벳 차이 (알파벳은 26개)
ord('Z') - ord('A')
> 25

permutations / combinations

from itertools import permutations

list(permutations([1, 2, 3], 2)
> [(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]

from itertools import combinations

list(combinations([1, 2, 3], 2))
> [(1, 2), (1, 3), (2, 3)]

f string

num = 0.4
print(f'{num:.4f}')
> 0.4000

에러 메시지

TypeError: 'int' object is not iterable

for문에서 iterable한 객체를 사용하지 않은 경우

TypeError: 'str' object cannot be interpreted as an integer

문자형 데이터를 정수형처럼 사용한 경우

[레퍼런스] 혁펜하임 Easy! 딥러닝

Tue, 08 Apr 2025 07:14:50 GMT

인공지능의 분류

AI $\supset$ ML $\supset$ DL

인공지능(AI) : 인간의 지능을 인공적으로 만든 것
머신러닝(ML) : 데이터 기반 인공지능
딥러닝(DL) : DNN을 활용한 인공지능
머신러닝이 아닌 인공지능 : 규칙 기반 알고리즘

인공신경망

AI가 학습한다 = 적절한 weight와 bias를 찾는다

weight(중요도) 곱하고 bias(민감도) 더해서 activation

weight : 신경 부위 별 중요도
bias : 신경 활성화 여부에 대한 민감도 조절

input layer : input data(3) hidden layer 1 : output from input layer(3) + weight(12) + bias(4) + activation function(4) hidden layer 2 : output from hidden layer 1(4) + weight(16) + bias(4) + activation function(4) output layer : output from hidden layer 2(4) + weight(4) + bias(1) + activation function(1)

Self-Supervised Learning

적은 데이터로도 효과적으로 학습이 가능하기 때문에 여러 분야에 활용되고 있다.
데이터 수집에는 많은 비용이 필요하기 때문에 효율적인 학습을 위해 자기지도 학습이 중요하다.

자기지도학습 과정

pretext task를 학습하여 pre-training : 진짜 문제를 학습하기 이전에 가짜 문제를 연구자가 새롭게 정의하여 사전 학습
- 연구자가 정의한 인위적인 문제(pretext task)를 통해 모델이 데이터의 기본적인 특징을 학습하도록 한다.
- 예를 들어, 이미지의 일부를 가리고 나머지 부분으로 가려진 부분을 예측하거나, 문장 내의 단어 순서를 섞은 후 원래 순서를 맞추는 등의 task를 설정할 수 있다.
- 이 단계에서는 실제 목표(downstream task)와는 직접적인 관련이 없지만, 모델이 데이터의 전반적인 구조와 패턴을 이해하는 데 도움을 준다.
downstream task를 풀기 위해 transfer learning : 진짜 문제를 풀기 위해 전이 학습
- Pre-training 단계에서 학습된 모델의 지식을 실제 목표 문제(downstream task)에 전이하여 학습한다.
- 일반적으로 pre-trained 모델의 일부 레이어만 fine-tuning하거나, pre-trained 모델을 feature extractor로 사용하여 downstream task를 위한 별도의 모델을 학습시킨다.
- Pre-training을 통해 얻은 지식은 downstream task의 성능 향상과 학습 속도 개선에 기여할 수 있다.

대표적인 자기지도 학습

Context Prediction (2015)

이미지에서 3×3개의 patch 추출 가운데 patch와 다른 임의의 patch 1개를 모델에 입력 입력받은 임의의 patch의 위치를 맞추는 방식으로 학습

Contrastive learning (2020)

유사한 이미지는 가깝게 임베딩되고, 다른 이미지는 멀게 임베딩되도록 학습

딥러닝 학습

Loss

AI 학습은 최적의 weight와 bias를 찾는 과정이다. Loss는 최적의 weight와 bias를 찾는 수단이다. Loss는 일반적으로 AI의 예측값과 실제값의 차이로 정의한다. Loss를 최소화하는 weight와 bias 탐색한다.

Gradient descent

경사 하강법

Gradient : 기울기 weight와 bias의 초기값은 랜덤으로 정한다. 현재의 weight, bias의 위치에서 Loss를 줄이는 방향으로 나아간다. 수학적으로 Gradient는 항상 가파른 방향을 가리킨다. (Loss를 올려주는 방향) Gradient의 반대 방향으로 가면 Loss의 최소값을 향해 갈 수 있다.

weight 초기화

초기값은 균등분포나 정규분포를 활용하여 랜덤하게 0 근처로 설정한다.

Learning Rate

Gradient는 학습에 사용하기에 크기가 너무 크다. Learning Rate를 곱해서 학습에 사용한다. 보편적으로 0.001을 많이 사용한다.

경사 하강법의 단점

모든 데이터를 고려하여 Loss를 구한다.
local minimum에 빠질 수 있다.

Stochastic Gradient descent

확률적 경사 하강법

경사 하강법은 모든 데이터를 활용하여 Loss를 만든다. 확률적 경사 하강법은 데이터 중에 하나씩 랜덤으로 뽑아서 Loss를 만든다. Loss 미분 과정에서 계산 복잡성이 줄어들어 더 빨리 수렴한다. 비복원 추출이고, 모든 데이터를 사용하면 1 epoch이다.

확률적 경사 하강법의 장점

데이터를 하나씩 고려하여 Loss를 구하기 때문에 계산이 빠르다.
local minimum으로부터 탈출의 기회가 되기도 한다. 가장 가까운 local minimum의 방향으로 곧장 가지는 않기 때문이다.

Mini-Batch Gradient descent

미니배치 경사 하강법

데이터 중에서 Batch size만큼 랜덤으로 뽑아서 Loss를 만든다. Batch size = 1 : 확률적 경사 하강법 Batch size = Data size : 경사 하강법

GPU 병렬 연산의 발전으로 경사 하강법이 느리다는 문제는 해결되었지만, local minimum에 빠지는 것을 어느정도 막을 수 있기 때문에 미니배치 경사 하강법을 사용한다.

Batch Size 결정

실험을 통해 Batch size를 키울수록 성능이 하락한다는 사실이 알려져있다. Batch size가 클수록 경사 하강법에 가까워지므로, 랜덤하게 시작한 위치에서 가까운 local minimum에 빠지는 경향이 있다.

Batch size를 키우고 싶으면 Learning rate를 조정하면 된다. Batch size는 Learning rate를 조정하면 ImageNet 데이터 기준으로 8k까지가 적당하다.

Batch size를 키우는만큼 Learning rate도 같이 키우기
warmup 사용하기

Batch size를 키울 때, Learning rate도 같이 키우는 것이 좋다. Batch size를 2배 키우면 Learning rate도 2배 키워야 균형이 맞는다.

Batch size가 32일때, 64개의 데이터로 weight를 업데이트하는 상황 $w_2 = w_1 - \frac{\alpha}{32} \sum_{1}^{32}g_1$ $w_3 = w_2 - \frac{\alpha}{32} \sum_{1}^{32}g_2$ $\rarr w_3 = w_1 - \frac{\alpha}{32} \sum_{1}^{32}g_1 - \frac{\alpha}{32} \sum_{1}^{32}g_2$
Batch size가 64일때, 64개의 데이터로 weight를 업데이트하는 상황 $w_2 = w_1 - \frac{\alpha}{64} \sum_{1}^{64}g_1$

warmup은 학습 초기에 Learning rate를 0부터 증가시키는 기법이다.

cf) 익숙한 이 그림에서 확률적 경사 하강법은 왜 정방향으로 가지 않을까?

그림의 등고선은 전체 데이터를 고려한 Loss에 대한 것이다. 화살표는 전체 데이터를 고려한 방향이 아니라 랜덤으로 추출한 하나의 데이터에 대한 Loss이다. 따라서 전체 데이터를 고려한 Gradient의 반대 방향은 아니지만 여러번 반복되면 결국 목적지에 도착한다.

딥러닝 학습 용어

Epoch : 전체 데이터를 몇번 반복해서 볼거냐 Batch size : 몇개씩 볼거냐 Learning rate : 얼만큼 업데이트 할거냐

Parameter : AI가 스스로 알아내는 변수 ex) weight, bias ... Hyperparameter : 사람이 정해줘야하는 변수 ex) Epoch, Batch size, Learning rate, Initial weight, Model architecture, Loss function, Optimizer ...

Reference

혁펜하임 YouTube

[레퍼런스] Linux

Tue, 08 Apr 2025 07:04:54 GMT

@ 디스크 용량 확인 df -h : 디스크 남은 용량 확인 df . -h : 현재 경로의 디스크 남은 용량 확인 du . -h | sort -h (r) : 현재 경로의 폴더 용량 확인

@ 디렉터리, 파일 제거 rm -r [폴더명] : 하위 디렉터리까지 제거 (-h : 삭제할지 질문)

@ ipynb_checkpoint & pycache 제거 find . -type d -name '.ipynb_checkpoints' -exec rm -r {} ; find . -type d -name 'pycache' -exec rm -r {} ;

@ conda/pip cache 파일 삭제 conda clean --all pip cache purge

@ 압축 tar : 파일, 디렉터리를 하나로 통합 tar 생성 : tar -cvf [파일명] [통합할 폴더명] ex) tar -cvf achive-name.tar directory-name tar 풀기 : tar -xvf [파일명] [-C 경로] ex) tar -xvf achive-name.tar zip 생성 : zip -r compressed.zip ./compressed

tar.gz : tar 상태에서 gzip으로 압축 tar.gz 압축 : tar -zcvf [압축명] [압축할 폴더(파일)명] ex) tar -zcvf achive-name.tar.gz directory-name tar.gz 압축풀기 : tar -zxvf [압축파일명] [-C 경로] ex) tar -zxvf achive-name.tar.gz zip 압축풀기 : unzip compressed.zip (현재위치에 폴더 없이 풀림) zip 특정폴더에 압축풀기 : unzip compressed.zip -d ./compressed (폴더는 미리 만들어야함) 압축 해제하지 않고 압축파일 내의 목록 출력 : unzip -l compressed.zip

@ GPU 사용 CUDA_VISIBLE_DEVICES=2,3 python train.py # gpu 할당 in terminal

@ 서버 가상환경 설정 conda create -n 가상환경이름 python=파이썬버전 # 가상환경 생성 conda activate 가상환경이름 # 가상환경 실행 conda install ipykernel ipython kernel install --user --name=가상환경이름 # kernel 등록 jupyter kernelspec list

jupyter kernelspec uninstall 커널이름 # kernel 지우기 conda env remove --n 가상환경이름 # 가상환경 지우기 conda env list # 가상환경 리스트 conda install -n 가상환경이름 -y 패키지이름 # 가상환경에 패키지 설치 conda install -n "나의가상환경이름" pytorch torchvision torchaudio -c pytorch # 가상환경에 pytorch 설치 conda install -n "나의가상환경이름" -c anaconda tensorflow-gpu==2.2.0 # 가상환경에 tensorflow-gpu 설치 pip3 install torch torchvision torchaudio

@ 주피터노트북에 가상환경 연결 pip install jupyter notebook python -m ipykernel install --user --name 가상환경이름 --display-name "표시할 커널이름"

@ 폴더 복제 cp -r foler_name folder_name2 : 이름 바꿔서 현재 경로에 복제

@ 패키지 설치/삭제 [pip/conda] [install/uninstall] 패키지명

@ RTX 3090 지원 pytorch 설치 pip install torch==1.7.1+cu110 torchvision==0.8.2+cu110 -f https://download.pytorch.org/whl/torch_stable.html

@ 메모리 사용량 확인 free -mh

@ 파일이름 텍스트파일로 ls /opt/dataset/fish/*jpg > fish_train.txt

@ gpu 정보 gpustat : gpu 사용량 gpustat -i : gpu 사용량 실시간 nvidia-smi : gpu 상세확인, cuda version 확인

@ 파일/폴더 이름 변경 mv 원본이름 변경할이름

@ 확장자 일괄 변경 for f in *.기존; do mv -- "$f" "${f%.기존}.신규"; done

@ 가상환경 python 버전 변경 python -V : 파이썬 버전 확인 conda search python : 사용 가능한 python list 확인 conda install python=x.x.x : 파이썬 버전 변경

@ tmux 명령어 tmux # 터미널에서 tmux 실행 tmux exit # 터미널에서 실행한 tmux 종료 -> session 삭제됨 tmux ls # session 목록 확인 tmux new -s session_name # 터미널에서 새 session 생성 tmux attach(a) -t session_name # 터미널에서 특정 session 들어가기 tmux switch-client -t session_name # tmux 창에서 session 전환 tmux kill-session -t session_name # 특정 session 삭제

[레퍼런스] Python

Tue, 08 Apr 2025 07:00:06 GMT

@ html 특수문자 변환 import html html.unescape("I don't care") -> "I don't care"

@ 문자열 형태의 리스트, 리스트 형식으로 변환 eval(문자열) : 문자열 형태의 명령어 실행

@ 딕셔너리 하나 출력 keys = list(dict_.keys()) dict_[keys[0]]

@ 딕셔너리 출력 dict(sorted(dict_name.items())[:5])

@ 딕셔너리 반복문 for key, value in dictname.items() :

@ 데이터프레임 조건문 data[data['match']=='Pass'] data.loc[data['match']=='Pass']

@ 2차원 리스트 해제(1차원으로) my_list = [[1, 2], [3, 4], [5, 6]] answer = sum(my_list, [])

@ 데이터프레임 중복 제거 df = df.drop_duplicates(ignore_index=True) 중복 행 확인 : df[df.duplicated(keep=False)]

@ 데이터프레임 to 시리즈 df.squeeze()

@ 반복문 인덱스 출력 for i, num in enumerate(numbers) :

@ 데이터프레임 결측치 제거 : df = df.dropna() 확인 : df[df['col_name'].isnull()]

@ GPU 사용 import os # gpu 할당 in jupyter os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID" os.environ["CUDA_VISIBLE_DEVICES"]= "2,3"

@ 데이터프레임 조건 수정 df.loc[df['grades'] == 90, 'result'] = 'A'

@ 시드 고정 def seed_all(seed) : os.environ["PYTHONHASHSEED"] = str(seed) random.seed(seed) np.random.seed(seed) torch.manual_seed(seed) # pytorch torch.cuda.manual_seed_all(seed) torch.cuda.manual_seed(seed) torch.backends.cudnn.benchmark = False torch.backends.cudnn.deterministic = True # 속도 저하 있음 os.environ['TF_DETERMINISTIC_OPS'] = '1' # tensorflow tf.random.set_seed(seed)

@ 연산 기호 나머지 : % 몫 : //

@ 데이터프레임 분할 df.iloc[:100000]

@ 오류 무시 try : code~ except : pass

@ print 변수 출력 print("정수 : %d, 실수 : %.10f" % (num1, num2)) print("퍼센트 : %d%%" % num)

@ 반복문 변수 2개 for n1, n2 in zip(x, y):

@ CUDA ERROR 쿠다 에러 device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")를 device = torch.device("cpu")로 바꾸면 구체적인 오류가 출력됨

@ re.sub 사용법 [0-9]+ : 숫자 여러개 ex) re.sub(r"[0-9]+_", "", text)

@ 파일명, 폴더명 일괄 변경 import re import os

path = "./fish2_1-396" names = os.listdir(path)

for name in names : new = re.sub(r"[0-9]+_", "", name) new = os.path.join(path, new) name = os.path.join(path, name) os.rename(name, new)

@ pickle f = open('file_name', 'wb') pickle.dump(obj1, f) pickle.dump(obj2, f) f.close() f = open('file_name', 'rb') d = pickle.load(f) # obj1 로드 print(d) d = pickle.load(f) # obj2 로드 print(d)

@ pickle while with open(file, "rb") as f: while True: try: obj = pickle.load(f) except EOFError: break

@ 데이터프레임 사용할 열만 불러오기 pd.read_csv('file_name.csv', usecols=[col_name1, col_name2])

@ 한글을 포함한 csv 불러오기 pd.read_csv('data.csv', encoding='utf-8') pd.read_csv('data.csv', encoding='cp949')

@ csv 저장 data.to_csv('data.csv', index=False, encoding='utf-8')

@ 데이터프레임 열 이름 변경 df.columns = ['col1', 'col2', 'col3'] # 전체 df.rename(columns={'Before':'After'}) # 선택

@ 리스트 특정 원소 제거/삭제 list_ = [1,2,3,4,4,5] list_.remove(4) # 결과 : [1,2,3,4,5] list_ = [[1,2,3], [1,2,3]] for l in list_ : l.remove(1) # 결과 : [[2, 3], [2, 3]]

@ 리스트 원소 인덱스로 제거/삭제 list_ = [1, 2, 3, 4] del list_[1] # [1, 3, 4]

@ tqdm while with tqdm(total=len(a)) as pbar: d = 0 while d < 100: pbar.update(1) print(a[d]) d += 1

@ 코드 실행 시간 import time start_time = time.time() end_time = time.time() t = end_time - start_time # 초단위 print('RunTime: %dh %dm %ds' % (t//60//60, t%60, t%60%60))

@ 리스트 원소 개수 세기 a = ['blue', 'blue', 'red', 'orange', 'green', 'green', 'blue', 'gray'] a.count('blue') # 3

@ 특정 단어를 포함하는 경우 새로운 열 추가 data['새로운 열'][data['찾을 열'].str.contains('특정 단어')] = 새로운 열의 값

@ apply + lambda 사용법 df['colname'] = df['colname'].apply(lambda x : eval(x))

@ 폴더 생성

이미 존재하는 폴더 에러 안남, 폴더 여러개 생성 가능
os.mkdir은 FileExistsError 발생, 폴더 한개만 생성 가능 os.makedirs('./folder1/folder2', exist_ok=True)

@ windows venv 가상환경 (python 설치시 Add python.exe to PATH 체크) [cmd] install : python -m venv myvenv activate : .\myvenv\Scripts\activate.bat [bash] install : python -m venv myvenv activate : source myvenv/Scripts/activate bash: $'\r': command not found 오류 -> sed -i -e 's/\r$//' myvenv/Scripts/activate

@ windows airflow 설치 bash 실행

@ 파이썬 버전에 맞는 airflow 설치 AIRFLOW_VERSION=2.6.3 PYTHON_VERSION=$(python --version | cut -d" " -f2 | cut -d"." -f1,2) CONSTRAINT_URL="https://raw.githubusercontent.com/apache/airflow/constraints-${AIRFLOW_VERSION}/constraints-${PYTHON_VERSION}.txt" pip3 install "apache-airflow==${AIRFLOW_VERSION}" --constraint "${CONSTRAINT_URL}"

[논문] Large Language Models for Next Point-of-Interest Recommendation

Fri, 04 Apr 2025 01:52:30 GMT

📄 Paper

Large Language Models for Next Point-of-Interest Recommendation [arxiv]

Peibo Li SIGIR 24

📝 Key Point

LLM을 활용하여 다음 관심 지점(Next Point-of-Interest, POI)을 예측하는 새로운 추천 시스템 LLM4POI를 제안한다.
LLM을 통해 위치 기반 소셜 네트워크 데이터의 풍부한 맥락 정보를 활용한다.
LLM을 사용하여 데이터를 질문-응답 형식으로 변환하고, "Trajectory Prompting"과 "Key-Query Pair Similarity"를 도입하여 사용자 행동 패턴을 분석한다.
LLM4POI가 기존 시스템보다 추천 정확도가 높고, 콜드 스타트와 짧은 경로 문제를 완화한다.

Abstract

문제 정의 :

Next Point-of-Interest (POI) Recommendation Task : 사용자의 이전 방문 데이터를 바탕으로 다음 방문할 POI를 예측한다.
도전 과제 : LBSN(Location-Based Social Network) 데이터의 풍부한 맥락 정보를 효과적으로 활용하는 방법이 부족하다.
기존 방법은 데이터의 수치화에 의존하여 맥락 정보의 의미를 충분히 반영하지 못한다.

해결 방법 :

LLM을 활용한 프레임워크를 제안한다.
- 이질적인 LBSN 데이터를 원본 형식 그대로 유지하면서 맥락 정보를 보존한다.
- 상식적 지식을 통합하여 데이터의 의미를 이해하고 활용한다.

실험 결과 :

세 개의 실제 LBSN 데이터셋(Foursquare-NYC, Foursquare-TKY, Gowalla-CA)에서 실험했다.
제안된 프레임워크가 모든 데이터셋에서 기존 SOTA 모델들보다 우수한 성능을 보인다.

결론 :

제안된 프레임워크는 맥락 정보를 효과적으로 활용하여 성능을 크게 개선한다.
일반적인 문제인 cold-start와 짧은 궤적 문제(short trajectory problem)를 완화한다.

Figure

키-쿼리 유사성 (Key-Query Similarity) :
- 사용자 행동 패턴을 분석하기 위해 궤적 간의 유사성을 계산한다.
- 높은 유사성을 가진 궤적을 선택하여 역사적 궤적 블록으로 사용하는 방식으로 설계한다.
궤적 프롬프팅 (Trajectory Prompting) :
- 사용자의 체크인 데이터를 자연어 질문-응답 형식으로 변환하여 LLM에 입력 가능하도록 재구성한다.
- 현재 궤적, 역사적 궤적, 지침, 목표를 나타내는 여러 블록으로 구성된 프롬프트를 형성한다.
지도학습 기반 파인튜닝 (Supervised Fine-Tuning) :
- 대규모 언어 모델을 fine-tuning하여 POI를 예측한다.
- 프롬프트를 통해 입력 데이터를 처리하고 적절한 POI 추천을 생성한다.

1. Introduction

문제 정의

Location-Based Social Networks (LBSNs) :
- 모바일 및 위치 기술의 발전으로 인해 LBSN은 풍부한 위치 기반 정보를 제공하며 성장했다.
- Next Point-of-Interest (POI) Recommendation Task : 사용자의 역사적 궤적 데이터를 기반으로 다음 POI 방문을 예측한다.
기존 모델의 한계 :
- 짧은 궤적 문제(short trajectory problem)와 cold-start 문제를 일부 해결했지만, 풍부한 맥락 정보를 충분히 활용하지 못한다.
- 데이터의 통계적 접근에만 의존하여 사용자 행동 모델링의 잠재력을 제한한다.

도전 과제

맥락 정보 추출
- 문제 : LBSN 데이터는 시간, POI 카테고리, 지리 좌표 등 풍부한 정보를 포함하고 있지만, 기존 방법들은 이 정보를 원시 데이터에서 효과적으로 추출하는 데 한계를 보인다.
- 중요성 : 이 정보는 통계적 분석을 넘어, 데이터에 존재하지 않는 행동 패턴까지 도출 가능하며 사용자 행동을 더 정밀하게 모델링할 수 있다.
상식 지식과의 연결
- 문제 : 맥락 정보와 실세계 행동 간의 상호 연결을 어떻게 효과적으로 구현할 것인가?
- 상식적 지식 : 추가 데이터 없이 맥락 정보를 이해하고, 데이터에서 존재하지 않는 행동 패턴을 유추할 수 있게 한다.

기존 방법의 한계

수치 기반 변환의 제약 :이질적 LBSN 데이터를 숫자로 변환할 필요성 때문에 데이터의 고유한 의미가 손실된다.
통계적 접근 및 설계 의존 :통계와 인간 설계만으로 맥락 정보를 이해하며, 의미론적 개념을 제대로 활용하지 못한다.

제안된 해결 방법

LLM4POI 프레임워크 :
- LLM을 활용하여 다음 POI 추천 문제를 해결한다.
- 원시 데이터를 텍스트 형식 그대로 유지하며 맥락 정보를 보존한다.
- 상식적 지식을 통합하여 데이터의 의미를 파악하고 사용자 행동 패턴을 모델링한다.
맥락 정보 보존
상식적 지식 통합

주요 기여

풍부한 맥락 정보와 상식적 지식을 결합하여 데이터의 고유 의미를 유지하며 모델링한다.
짧은 궤적 문제(short trajectory problem)와 cold-start 문제를 완화한다.
실험을 통해 기존 SOTA 모델을 초월하는 성능을 입증되었다.

2.1 Next POI Recommendation

Sequence-based Models

초기에 POI 추천은 순차적 추천 문제로 간주되어 기존 순차적 추천 기법이 적용되었다.
- Cheng et al. [4] : 국소 지역 제약을 적용한 FMPC 도입.
- He et al. [14] : 소프트맥스 함수와 결합된 개인화 마르코프 체인을 도입.
- HST-LSTM (Kong & Wu [17]) : 시공간 요소를 LSTM 게이트에 추가.
- LSTPM [22] : 세 가지 LSTM 모듈과 지오-확장 LSTM을 통해 짧은 선호 모델링 수행.
- STAN [19] : 다층 attention 아키텍처로 사용자, 위치, 시간 및 공간적 효과 학습.
- CFPRec [33] : 과거 및 현재 선호도를 인코더를 통해 다중 참조 추출.

Graph-based Models

시퀀스 기반 모델의 한계를 해결하기 위해 그래프 기반 방법론이 등장했다.
- STP-UDGAT [18] : GAT를 활용해 전역적 관점에서 데이터 학습.
- DRGN [26] : 거리 및 전이 기반 관계 그래프를 통해 POI의 특성 분석.
- STHGCN [30] : 하이퍼그래프를 구축하여 사용자 궤적 및 관계를 포착.
기존 모델의 한계 :
- 맥락 정보와 상식 지식을 결합하는 데 제한적이다.

2.2 LLMs for Time-series Data

LLM은 시계열 데이터에 효과적인 것으로 입증되었다.
- SHIFT [28] : 인간 이동성을 언어 번역 문제로 간주하며 LLM 활용.
- AuxMobLCast [28] : 시계열 데이터를 위한 프롬프트 설계 연구.
- LLM4TS [2] : 두 단계 fine-tuning 접근법(기본 정렬 후 다운스트림 특화 학습)을 채택.
제안 방법 : 위 연구에 영감을 받아 LBSN 데이터의 특성을 반영한 trajectory prompting 설계를 통해 POI 추천을 질문-응답 문제로 변환한다.

2.3 LLMs for Recommender Systems

다양한 추천 시스템에서 LLM이 도입되고 있다.
- Zhang & Wang [34] : 뉴스 데이터를 위한 프롬프트 템플릿 설계 및 앙상블 학습.
- Harte et al. [13] : 항목 임베딩 기반 추천, 프롬프트 완료 및 기존 모델 향상 기법 제안.
- Wang et al. [25] : POI 추천에 LLM의 컨텍스트 학습 적용.
제안 방법 : LLM의 fine-tuning과 궤적 유사성을 결합해 POI 추천 성능을 극대화한다.

3. Problem Definition

문제 정의

이 논문은 다음 POI(관심 지점) 추천 작업을 위해 LLM을 fine-tuning하는 문제를 해결하는 데 초점을 맞추고 있다.

데이터셋 구조

데이터셋 $D$는 사용자 체크인 기록으로 구성된다. 각 기록은 다음 정보를 포함하는 튜플 $q=(u,p,c,t,g)$형태로 표현된다

$u$ : 사용자
$p$ : POI(Point-of-Interest)
$c$ : POI의 카테고리
$t$ : 체크인 타임스탬프
$g$ : POI의 지리적 좌표

궤적 형성

특정 시간 간격 $\Delta t$ 기준으로 사용자의 체크인 기록을 분할하여 궤적을 형성한다. 사용자의 궤적 $T_i^u(t)$는 다음과 같은 체크인 기록의 집합으로 구성된다. $$ T_i^u(t) = {(p_1, c_1, t_1, g_1), \dots, (p_k, c_k, t_k, g_k)} $$ $$ (t_1 < t_2 < \dots < t_k = t \quad \text{and} \quad t_k - t_1 \leq \Delta t) $$

목표

새로운 궤적 $T_i^u(t)$에서 사용자의 다음 체크인 POI $p_{k+1}$을 예측해야 한다. 사용자가 $t_{k+1}$ 시점에 즉시 방문할 POI를 예측한다는 목표로 정의된다.

4. Methodology

전체 프레임워크

Key-Query Similarity : 키와 쿼리 간 유사성을 계산해 관련 궤적 데이터를 선택한다.
Trajectory Prompting : 사용자의 체크인 데이터를 LLM이 이해할 수 있는 질문-응답 형식으로 변환한다.
Supervised Fine-Tuning : 프롬프트를 활용하여 LLM을 지도 학습 기반으로 파인튜닝한다.

4.1 Trajectory Prompting

아이디어 :

LBSN 데이터를 자연어 문장으로 변환하여 이질적인 데이터를 의미 있는 문장으로 통합한다.
프롬프트는 다음과 같은 블록들로 구성된다.
1. Current Trajectory Block : 현재 사용자 궤적 데이터(마지막 항목 제외).
2. Historical Trajectory Block : 현재 사용자와 유사한 행동 패턴을 보이는 사용자의 데이터.
3. Instruction Block : 모델에게 초점을 맞추어야 할 지점과 POI ID 범위를 안내한다.
4. Target Block : 예측해야 할 체크인 레코드(지도 학습 평가용).

프롬프트와 Check-in 기록

Check-in 기록은 다음과 같은 형식으로 변환한다.
- "At [time], user [user id] visited POI id [poi id] which is a/an [poi category name] with category id [category id]."
지리적 좌표(geo-coordinates)는 제외하여 토큰 수를 줄이고 효율성을 높인다.

특징 및 이점

현재 궤적 블록은 짧은 궤적 문제(short trajectory problem)를 해결하고, 역사적 궤적 블록은 다른 사용자 데이터를 활용하여 cold-start 문제를 해결한다.
명령 블록을 통해 모델이 특정 범위 내에서 예측하도록 유도한다.
입력 중 목표 블록은 예측 단계에서 제외하여 평가에 사용된다.

주요 설계 특징

데이터의 원래 형식을 유지하면서 문장으로 통합해 LLM에 입력한다.
블록 구조는 수정 및 확장이 용이하도록 설계된다.

4.2 Key-Query Pair Similarity

목적

사용자 행동 패턴을 포착하고, 사용자별로 혹은 다른 사용자의 궤적 데이터를 활용해 맥락적 정보를 반영한다.
Key-Query Similarity Computation Framework를 사용하여 궤적 데이터를 자연어 형식에서 효과적으로 처리한다.

주요 개념

Key와 Query의 정의
- Key : 현재 궤적 블록에 포함된 궤적으로, 마지막 항목을 제외한 데이터를 활용한다.
- Query : Key 궤적의 시작 시간보다 더 이른 궤적으로, 전체 궤적 데이터를 포한다.
Key와 Query 간 유사성 계산
- 각 Key와 Query 쌍의 유사성을 계산하여 관련성이 높은 Query를 선택한다.
- 높은 유사성을 가진 Query를 선택하여 역사적 궤적 블록에 사용한다.

처리 과정

Key와 Query Prompt 생성
- Key Prompt : 현재 궤적 데이터(마지막 항목 제외)를 사용해 생성한다.
- Query Prompt : 과거의 전체 궤적 데이터를 기반으로 생성한다.

LLM 기반 임베딩 생성
- Key Prompt와 Query Prompt를 각각 LLM(e.g. LLAMA2 Encoder)에 입력하여 마지막 hidden layer의 임베딩을 생성한다.

코사인 유사도 계산
- Key와 Query 간의 코사인 유사도 $\text{Sim}(E_k, E_q)$를 계산한다. $$ \text{Sim}(E_k, E_q) = \frac{E_k \cdot E_q}{|E_k||E_q|} $$
상위 Query 선택
- 유사도 기준으로 상위 $k$개의 Query를 선택한다.

핵심 장점

높은 유사성을 가진 Query를 활용해 현재 궤적과 연관된 정보를 역사적 궤적 블록에 통합한다.
짧은 궤적 문제와 cold-start 문제를 효과적으로 완화한다.

4.3 Supervised Fine-tuning

Supervised Fine-tuning은 LLM을 효율적으로 파인튜닝하기 위한 과정으로, Parameter-Efficient Fine-Tuning (PEFT) 기술을 사용해 비용을 절감하면서 높은 성능을 유지하는 것을 목표로 한다.

Low-Rank Adaptation (LoRA)

목적 : LLM의 dense layers을 고정하고, rank가 낮은 행렬을 활용해 가중치를 업데이트하여 효율적인 학습을 진행한다.
작동 방식 :
- 사전 학습된 가중치 행렬 $$W_0 \in \mathbb{R}^{d \times k}$$에 대해, $$W_0 + \Delta W$$를 저차 분해 $$W_0 + L_1 L_2$$로 대체한다.
- $$L_1 \in \mathbb{R}^{d \times r}$$, $$L_2 \in \mathbb{R}^{r \times k}$$이며, $$r \ll \min(d, k)$$. 즉, 매우 작은 차원 $$r$$을 사용한다.
- 학습 중에는 $$L_1$$과 $$L_2$$만 gradient 업데이트를 받으며 나머지 가중치는 고정된다.
- 예시 : Attention 레이어(4096 elements)에서는, rank를 16으로 설정하면 학습 가능한 매개변수가 0.78%로 감소한다.
장점 : MLP 레이어는 고정되고, Attention 레이어만 파인튜닝하므로 계산 비용을 크게 절감한다.

Quantization

목적 : GPU 메모리 사용량을 줄이고 계산 효율성을 증가시킨다.
기술 :
- 고비트 데이터를 저비트 데이터로 변환한다.
- 4-bit NormalFloat(NF4)을 사용한다.
  - 평균 0, 범위 [-1, 1] 내의 정규 분포에 최적화한다.
  - 텐서를 rescale하고 양자화 상수를 적용한다.
- 이중 양자화(double quantization)를 적용한다.
  - 저장 시 NF4, forward 및 backward pass에서는 16-bit BrainFloating(BF)을 사용한다.
- gradient는 LoRA 파라미터에 대해서만 계산된다.

Flash Attention

문제 : 긴 문맥 길이가 필요한 경우, 기존 Transformer의 4096 토큰 길이는 부족하다.
해결책 : FlashAttention-2 기술을 도입한다.
- Transformer가 긴 문맥 길이를 처리하도록 지원한다.
- 긴 궤적 및 역사적 궤적 블록 처리를 위한 적합한 솔루션을 제공한다.

5. Experiment

5.1 Experimental Setup

5.1.1 Datasets

데이터셋 : Foursquare-NYC, Foursquare-TKY, Gowala-CA.
- Foursquare-NYC와 Foursquare-TKY : 뉴욕과 도쿄 지역 데이터를 포함하며, 11개월 동안 수집된 기록이다.
- Gowala-CA : 캘리포니아 및 네바다 지역 데이터를 포함, 더 넓은 지역과 기간을 다룬다.
전처리 과정 :
1. 방문 기록이 10개 미만인 POI 제거.
2. 방문 기록이 10개 미만인 사용자 제외.
3. 24시간 간격으로 체크인 기록을 궤적으로 나누고, 1개만 포함된 궤적은 제거.
4. 80%는 학습 데이터, 10%는 검증 데이터, 나머지 10%는 테스트 데이터로 분류.
5. 학습 데이터에 등장하지 않는 사용자와 POI는 검증 및 테스트 세트에서 제거.

5.1.2 Baselines

FPMC : 마르코프 체인과 행렬 분해를 결합하여 위치 전이를 예측.
LSTM : 순차적 데이터의 단기 및 장기 의존성을 포착.
PRME : 사용자-POI 선호도를 학습하는 개인화 순위 모델.
STGCN : 시공간 간격을 효과적으로 모델링.
PLSPL : 짧은 선호도는 Attention 메커니즘으로, 긴 선호도는 병렬 LSTM 구조로 학습.
STAN : 사용자 궤적 내 공간-시간 상관 관계를 학습.
GETNext : Transformer와 GCN을 결합하여 전역 궤적 흐름 지도 및 효과적인 POI 임베딩 생성.
STHGCN : 하이퍼그래프를 구성하여 사용자 관계를 포착하고, 차가운 시작 문제를 해결.

5.1.3 Our Models

모델 변형 :
1. LLM4POI* : 현재 궤적 블록만 포함, 역사적 궤적 제외. Llama-2-7b-longlora-32k 사용.
2. LLM4POI** : 역사적 궤적 블록을 포함하되 Key-Query 유사성 미적용. LLAMA2-7b 사용.
3. LLM4POI : 현재 사용자와 다른 사용자 궤적을 포함한 Key-Query 유사성 적용. LLAMA2-7b 사용.

5.1.4 Evaluation Metrics

Accuracy@1 평가 :
- 상위 1개 추천 항목이 테스트 데이터에서 올바른 예측 항목인지 확인한다. $$ \text{Acc@1} = \frac{1}{m} \sum_{i=1}^m 1(\text{rank} \leq 1) $$
- 더 높은 값은 더 나은 성능을 의미한다.

5.1.5 Implementation Details

설정 :
- 학습률 : $2 \times 10^{-5}$
- GPU 당 batch 크기 : 1
- 토큰 길이 : 32,768
- Epoch : 3
- Nvidia A100 GPU 사용

5.2 Main Results

Accuracy@1 성능 비교

LLM4POI는 세 데이터셋 모두에서 가장 높은 Accuracy@1 점수를 기록했다.
- NYC: 0.3372 (23.3% 향상, STHGCN 대비)
- TKY: 0.3035 (2.8% 향상, STHGCN 대비)
- CA: 0.2065 (19.3% 향상, STHGCN 대비)

모델별 성능 패턴

LLM4POI : 역사적 데이터와 다른 사용자 데이터를 모두 사용하며 최고의 성능을 보인다.
LLM4POI* : 역사적 데이터를 사용하지 않으며 성능이 상대적으로 낮다.
LLM4POI** : 다른 사용자 데이터를 제외하고도 높은 성능을 유지한다.

역사적 데이터와 다른 사용자 데이터의 중요성

역사적 데이터를 사용하는 모델(e.g. GETNext, STHGCN)이 데이터를 사용하지 않는 모델보다 더 나은 성능을 보인다.
다른 사용자 데이터를 추가로 사용하는 경우(e.g. GETNext, LLM4POI), 성능이 더욱 향상된다.

지역별 데이터 특성

NYC 데이터셋 : 사용자와 POI 개수가 적고 POI 카테고리가 많아 학습이 쉬운 데이터 특성을 보여 더 높은 성능을 보인다.
- CA 데이터셋 : 넓은 지역과 상대적으로 적은 데이터로 인해 모델 성능이 낮다.

5.3 Analysis

5.3.1 User Cold-start Analysis

문제 : cold-start 문제를 해결하기 위해 역사적 궤적 블록과 Key-Query 궤적 유사성을 활용한다.
사용자 그룹 정의 :
- Inactive (비활성) : 궤적 개수가 하위 30%에 속하는 사용자.
- Normal (보통) : 궤적 개수가 중간에 해당하는 사용자.
- Very Active (매우 활성) : 상위 30%의 궤적 개수를 가진 사용자.
결과 :
- LLM4POI는 STHGCN 대비 비활성 사용자에 대해 NYC 데이터셋에서 두 배 이상의 성능 향상을 보인다.
- 도쿄와 캘리포니아에서도 약 50% 이상의 성능 향상을 보인다.
주요 발견 :
- 우리의 모델은 비활성 사용자에서 더 높은 성능을 기록한다.
- 반면 STHGCN은 매우 활성 사용자에서 더 나은 성능을 보인다.
- 도쿄와 캘리포니아의 사용자가 많아 협업 정보 활용에 제약이 발생한다.

5.3.2 Trajectory Length Analysis

문제 : 궤적 길이의 다양성이 POI 추천에 중요한 영향을 미친다.
- 짧은 궤적 : 공간-시간 정보가 제한되어 도전 과제가 된다.
- 긴 궤적 : 정보는 풍부하지만 패턴 추출의 어려움 존재한다.
궤적 길이 정의 :
- 상위 30% : 긴 궤적
- 하위 30% : 짧은 궤적
- 나머지 : 중간 궤적
결과 :
- NYC 데이터셋에서 짧은 궤적에 대해 Accuracy@1 24.4% 개선했다.
- 중간 궤적에서는 31.6% 개선했다.
- TKY 및 CA에서는 긴 궤적에서 더 나은 성능을 보인다.
결론 : 모델은 궤적 길이에 따라 균형 잡힌 성능을 유지하며 역사적 데이터를 효과적으로 통합한다.

5.3.3 Number of Historical Data Variants

문제 : 프롬프트의 토큰 제한으로 인해 선택된 최고 유사 궤적만 사용할 수 있다.
결과 :
- NYC : 100개의 역사적 체크인 기록에서 최고 성능.
- TKY : 300개의 역사적 체크인 기록에서 최고 성능.
- CA : 다양한 기록 개수에도 성능 차이가 거의 없음.
결론 :
- 더 많은 데이터를 사용할수록 성능이 반드시 개선되지 않는다.
- 적은 데이터를 사용해 토큰 크기를 줄이면서도 경쟁력 있는 성능 유지가 가능하다.

5.3.4 Generalization to Unseen Data Analysis

문제 : LLM4POI 모델은 순수한 언어 모델링 기반으로 POI ID를 예측하며, 데이터셋 간 전이 학습 없이도 성능을 평가할 수 있다.
결과 :
- NYC, TKY, CA 데이터셋 중 한 데이터셋에서 fine-tune한 모델을 나머지 데이터셋에서 테스트한 결과, 경쟁력 있는 성능을 보였다.
- 예를 들어, NYC에서 학습된 모델은 TKY에서 STHGCN보다 낮은 성능을 보였지만 CA에서는 기존 SOTA 모델보다 뛰어난 성능을 보인다.
결론 : 모델의 일반화 능력은 'Historical Trajectory Block'과 'Key-Query Similarity'가 효율적으로 사용자 이동 기록을 포착했기 때문이다.

5.3.5 Contextual Information Analysis

문제 : 문맥 정보를 활용하는 것은 LLM4POI 모델의 차별화된 특성 중 하나이다.
결과 :
- NYC, TKY, CA 데이터셋에서 문맥 정보를 포함한 프롬프트와 그렇지 않은 프롬프트로 모델을 테스트한 결과 : NYC에서 문맥 정보를 제거해도 성능은 약간 감소(1.8%)했지만 TKY와 CA에서는 각각 6.4%, 6.2% 감소한다.
- 활동 수준에 따른 분석 결과 : NYC와 CA에서는 활동이 적은 사용자의 성능이 향상되었고, 반대로 TKY에서는 활동적인 사용자의 성능이 향상된다.
결론 : 이러한 차이는 국가 간 POI 카테고리 분포의 차이와 연관이 있다.

5.3.6 Effect of Different Components

결과 : 모델 성능은 다음 3가지 주요 구성 요소의 결합 효과로 이루어진다.
1. Historical Trajectory Block : 이 구성 요소를 제거하면 TKY와 CA 데이터셋에서 정확도가 50%까지 급격히 감소한다.
2. Key-Query Similarity : 이 요소 제거 시 NYC에서 정확도 6% 감소한다.
3. Contextual Information : 문맥 정보 제거는 모든 데이터셋에서 성능 저하를 초래한다.
결론 : 각 구성 요소는 LLM4POI 모델 성능에 중요한 기여를 하며, 특히 'Historical Trajectory Block'이 가장 중요한 역할을 한다.

6. Conclusion and Future Work

주요 연구 제안

LLM4POI라는 프레임워크를 개발하여 대규모 언어 모델을 활용한 다음 관심 지점(Point-of-Interest, POI) 추천 과제를 수행했다.
처음으로 상식 기반의 대규모 언어 모델을 이 과제에 도입했다.
Trajectory Prompting을 통해 과제를 질문 답변 형태로 변환했다.
Key-Query Similarity를 소개하여 콜드 스타트 문제를 완화했다.

연구 결과 및 분석

실험 결과 : 세 가지 실제 데이터셋에서 기존 모델을 큰 차이로 능가했다.
분석 결과 :
- 콜드 스타트 문제와 다양한 길이의 사용자 이동 경로를 효과적으로 처리했다.
- 모델에서 맥락 정보의 중요성과 효과를 입증했다.
잠재성 : 대규모 언어 모델의 일반화 능력을 활용하여 새로운 데이터에서도 탁월한 성과를 보인다.

제약 및 향후 연구 방향

대규모 언어 모델의 특성상 학습 및 추론 시간 효율성 문제가 존재한다.
프롬프트 디자인이 모델의 컨텍스트 길이 및 사전 학습 코퍼스에 제한을 받는다.

향후 계획

현재의 제한점을 해결하는 연구를 진행한다.
Chain-of-thought reasoning을 통해 성능 향상 및 예측에 대한 설명을 제공한다.
단일 아이템 추천에 국한되지 않은 추천 시나리오로 모델로 확장한다.

[논문] Large Language Models meet Collaborative Filtering: An Efficient All-round LLM-based Recommender System

Thu, 03 Apr 2025 03:18:45 GMT

📄 Paper

Large Language Models meet Collaborative Filtering: An Efficient All-round LLM-based Recommender System [arxiv]

Sein Kim KDD 24

📝 Key Point

LLM과 협업 필터링(CF-RecSys)을 결합한 추천 시스템 A-LLMRec을 제안한다.
기존 CF-RecSys와 쉽게 통합 가능하며, 업데이트도 간단하다.
fine-tuning 없이 CF-RecSys의 협업 지식을 LLM이 직접 활용하도록 설계했다.
CF-RecSys의 협업 지식과 아이템 텍스트 정보를 결합하여 LLM의 입력으로 사용한다.
사용자의 행동 이력과 아이템 정보를 포함하는 텍스트 기반 프롬프트를 통해 맞춤형 추천을 수행한다.

Abstract

문제 정의 : 기존의 협업 필터링 기반 추천 시스템은 Cold 시나리오에서 성능이 저하되는 문제가 있다. 반면, LLM을 활용한 기존 접근법은 협업 지식이 부족해 Warm 시나리오에서 성능이 낮다.

연구 목표 : Cold 시나리오와 Warm 시나리오 모두에서 우수한 성능을 발휘할 수 있는 효율적인 추천 시스템인 A-LLMRec을 제안한다.

핵심 아이디어 : 사전 학습된 최신 CF-RecSys의 협업 지식을 LLM에 직접 전달하여, LLM의 새로운 능력과 CF-RecSys가 학습한 고품질 사용자 및 아이템 임베딩을 통합적으로 활용한다.

주요 장점 :

모델 독립성 : 다양한 CF-RecSys와 쉽게 통합 가능하다.
효율성 : CF-RecSys와 LLM의 추가적인 파인튜닝 없이 정렬 네트워크만 학습하여 효율적으로 성능을 극대화한다.

결과 : 실제 데이터셋 실험에서 A-LLMRec은 cold/warm, few-shot, cold user, cross-domain 시나리오에서도 우수한 성능을 보인다.

Figure

(a) Framework Overview

목표 : 협업 필터링 추천 시스템에서 얻은 협업 지식과 텍스트 정보를 LLM의 입력 토큰 공간에 결합한다.
과정 :
- 사용자-아이템 상호작용 이력을 CF-RecSys를 통해 학습한다.
- 아이템 텍스트 정보를 SBERT를 통해 학습한다.
- 상호작용 정보와 텍스트 정보를 A-LLMRec을 통해 결합하여 프롬프트를 생성한다.
- 프롬프트를 LLM에 입력하여 다음 아이템을 예측한다.
Trained / Frozen : CF-RecSys와 LLM은 Frozen하고, A-LLMRec만 학습시킨다.

(b) Stage 1 : Alignment between Collaborative and Textual Knowledge

목적 : 협업 지식과 텍스트 지식을 정렬(alignment)한다.
구성 요소 :
- SBERT(Sentence-BERT) : 텍스트 임베딩 추출.
- 아이템 및 텍스트 인코더 : CF-RecSys에서 얻은 아이템 임베딩을 텍스트 임베딩과 정렬.
- Loss 재구성 : 데이터의 원래 정보를 유지하며 과도한 평균화 방지.
이 과정에서 CF-RecSys와 SBERT를 함께 사용하여 고품질 임베딩을 생성한다.

(c) Stage 2 : Alignment between Joint Collaborative-Text Embedding and LLM

목적 : Stage 1에서 얻은 협업 텍스트 임베딩을 LLM의 토큰 공간과 정렬한다.
구성 요소 :
- 2-layer MLP : 사용자 표현과 공동 임베딩을 LLM의 토큰 공간으로 매핑.
- Prompt Engineering : 사용자 상호작용 이력과 아이템 정보를 포함하는 구조화된 프롬프트를 설계하여 LLM이 추천 작업을 수행하도록 지원.

1. Introduction

배경 및 문제 정의

추천 시스템의 발전에도 불구하고, 협업 필터링(CF) 모델은 사용자-아이템 상호작용 데이터가 희소한 Cold 시나리오에서 성능 저하를 겪고 있다.
최근 연구는 사용자 및 아이템의 텍스트나 이미지 같은 모달리티 정보를 활용하여 이러한 문제를 해결하려 했지만, Warm 시나리오에서는 협업 지식 부족으로 전통적인 CF 모델보다 성능이 낮아지는 한계가 있다.

모달리티 기반 접근법의 한계

LLM은 풍부한 언어 이해 능력 덕분에 모달리티 정보를 잘 활용하지만, 협업 지식 없이 Warm 시나리오에서 효과적이지 않다.
텍스트 정보는 Cold 시나리오에서는 유용하지만, 데이터가 풍부한 Warm 시나리오에서는 중요성이 줄어들며, ID 기반 CF 모델이 주도적인 역할을 한다.

문제의 중요성

실제 추천 시스템의 상호작용이나 수익은 대부분 Warm 아이템에서 발생한다. 이는 Warm 시나리오를 간과해서는 안 된다는 것을 의미한다.
Cold 아이템과 Warm 아이템 모두를 적절히 모델링해야 사용자 참여를 극대화할 수 있다.

제안 방법 : A-LLMRec

이 연구에서는 Cold 시나리오와 Warm 시나리오 모두에서 우수한 성능을 발휘하는 A-LLMRec을 제안한다.
A-LLMRec은 사전 학습된 CF-RecSys에서 학습된 협업 지식을 LLM에 직접 전달하여, CF-RecSys의 고품질 사용자/아이템 임베딩과 LLM의 새로운 능력을 결합한다.
이 방법은 추가적인 CF-RecSys나 LLM의 파인튜닝 없이, 정렬 네트워크만 학습해 효율적이고 실용적이다.

2.1 Collaborative Filtering

핵심 아이디어 : 사용자 및 아이템의 과거 상호작용 데이터를 활용해 추천을 생성하며, 유사한 사용자/아이템을 기반으로 추천을 수행한다.
진화 과정 :
- 행렬 분해(Matrix Factorization) : 잠재 요인을 활용하여 사용자 선호도를 효과적으로 포착하며, 확률적 행렬 분해(PMF)와 특이값 분해(SVD)로 발전하였다.
- 심층 신경망 사용 : AutoRec과 Neural Matrix Factorization(NMF)은 딥러닝을 사용해 복잡한 사용자-아이템 상호작용 패턴을 모델링하였다.
- 순차적 상호작용 : Caser와 NextItNet은 CNN을 활용해 사용자 상호작용 히스토리를 기반으로 협업 필터링을 개선하였다.
한계 : 사용자 및 아이템의 텍스트, 이미지 등 모달리티 정보 활용 부족으로 성능 향상이 제한적이다.

2.2 Modality-aware Recommender Systems

기본 개념 : 아이템의 텍스트 설명, 이미지 등 모달리티 정보를 활용하여 Cold 시나리오에서 추천 성능을 향상한다.
주요 모델 :
- NOVA와 DMRL은 텍스트와 아이템 임베딩을 효과적으로 통합하여 추천 성능을 개선하였다.
- MoRec은 BERT와 같은 사전 학습된 모달리티 인코더를 활용해 아이템의 텍스트 정보를 협업 필터링 모델에 통합하였다.
- RECFORMER는 Transformer 구조를 기반으로 텍스트 정보를 아이템 속성으로 변환하여 추천 작업을 수행하였다.
한계 : Warm 시나리오에서는 협업 지식 부족으로 성능이 저하되며, ID 기반 협업 필터링 모델에 비해 성능이 좋지 않다.

2.3 LLM-based Recommender Systems

기본 개념 : LLM의 풍부한 사전 학습 지식과 언어 이해 능력을 활용하여 추천 작업을 수행한다.
주요 연구 :
- In-context Learning : 다양한 프롬프팅 스타일(completion, instructions, few-shot prompts)을 활용하여 아이템 텍스트를 기반으로 추천 수행한다.
- TALLRec은 LoRA를 활용해 LLM을 fine-tuning하여 Cold 시나리오와 cross-domain 시나리오에서 효과적인 추천 성능을 제공한다.
한계 : 기존 모델은 추천 작업을 단순히 instruction 텍스트로 변환해 fine-tuning을 수행하나, 협업 지식을 명시적으로 포착하지 못해 Warm 시나리오에서는 성능이 제한적이다.

3. Problem Formulation

데이터 구성 요소

사용자와 아이템 : 데이터셋은 사용자 집합, 아이템 집합, 아이템 텍스트 정보(제목 및 설명), 그리고 사용자-아이템 상호작용 시퀀스로 구성된다.
아이템 상호작용 시퀀스 : 각 사용자에 대해 과거의 아이템 상호작용 이력으로 구성된 순서 데이터를 포함한다.
텍스트 정보 : 각 아이템은 텍스트 제목과 설명 정보를 가지고 있다.

문제 정의

목표 : 사용자의 과거 상호작용 기록을 기반으로 다음으로 추천할 아이템을 예측하는 것이다.
주어진 정보 : 사용자 상호작용 이력, 아이템의 텍스트 정보, 아이템의 벡터 임베딩

A-LLMRec의 확장성

모델 구조는 유연하며, CF-RecSys의 백본을 교체하거나 다양한 도메인에 적용 가능하다.
Cold 시나리오와 Warm 시나리오 모두에 적합한 방식으로 설계되었다.

4. Proposed Method: A-LLMRec

A-LLMRec은 최신 협업 필터링 추천 시스템(CF-RecSys)과 대형 언어 모델(LLM)을 결합하여 Cold 시나리오와 Warm 시나리오 모두에서 뛰어난 성능을 발휘할 수 있는 추천 시스템이다. 이를 위해 모달리티 차이를 줄이고 CF-RecSys의 협업 지식을 LLM의 토큰 공간과 정렬(alignment)하는 작업을 수행한다. 이 접근법은 크게 두 가지 단계로 구성된다.

4.1 Alignment between Collaborative and Textual Knowledge (Stage-1)

목표 : CF-RecSys로부터 얻어진 아이템 임베딩을 해당 텍스트 정보와 정렬하여 협업 지식과 텍스트 정보를 동시에 활용할 수 있도록 한다.

구성 요소 :

Sentence-BERT(SBERT) : 텍스트 정보를 임베딩하여 효율적으로 아이템의 텍스트 특징을 추출한다.
아이템 인코더 : CF-RecSys에서 얻은 아이템 임베딩을 잠재 공간으로 변환한다.
텍스트 인코더 : SBERT에서 추출된 텍스트 임베딩을 잠재 공간으로 변환한다.

정렬 과정 :

잠재 공간에서 아이템 임베딩과 텍스트 임베딩을 정렬하여 협업 정보와 텍스트 정보를 결합한다.
원활한 정렬을 위해 두 인코더를 훈련시키고, 추가적으로 원래 데이터의 정보를 보존하기 위해 디코더를 활용한다.
Cold 아이템이나 새로운 아이템의 경우, 텍스트 인코더를 통해 협업-텍스트 임베딩을 생성하여 활용한다.

4.1.1 Avoiding Over-smoothed Representation

문제점 :

단순히 협업 임베딩과 텍스트 임베딩의 정렬 손실($L_{matching}$)을 최적화하면 과도한 평균화(over-smoothing)가 발생할 수 있다. 즉, 인코더의 출력이 지나치게 비슷해져 $e_i \approx q_i$가 되는 문제가 생긴다.

해결 방법 :

인코더마다 디코더를 추가하여 원래 데이터 정보를 보존한다.
재구성 손실($L_{item-recon}$, $L_{text-recon}$)을 도입하여 인코더가 의미 있는 원래 정보를 유지하도록 학습시킨다.

4.1.2 Recommendation Loss

목적 : 협업 지식을 모델에 명시적으로 전달하고 추천 작업을 학습 목표로 포함시킨다. 정의 : 추천 작업에서 사용자-아이템 상호작용 이력과 정렬 임베딩을 활용하여 다음 아이템을 예측한다.

4.1.3 Final Loss of Stage-1

목표 : 정렬 Loss, 재구성 Loss, 추천 Loss를 통합하여 Stage-1의 최종 학습 목표를 정의한다. $$ L_{\text{stage-1}} = L_{\text{matching}} + \alpha L_{\text{item-recon}} + \beta L_{\text{text-recon}} + L_{\text{rec}} $$

4.1.4 Joint Collaborative-Text Embedding

정의 : $L_{\text{stage-1}}$로 학습된 아이템 임베딩을 협업-텍스트 임베딩으로 정의하며, 협업 지식과 텍스트 정보를 포함한다. Cold 아이템 처리 : 상호작용이 없는 아이템의 경우 텍스트 인코더를 사용하여 협업-텍스트 임베딩을 생성한다.

4.2 Alignment between Joint Collaborative-Text Embedding and LLM (Stage-2)

Stage-2의 목적은 Stage-1에서 생성된 Joint Collaborative-Text Embedding을 LLM의 토큰 공간과 정렬하고, 이를 통해 LLM이 추천 작업을 수행할 수 있도록 구성하는 것이다. 이 단계는 크게 두 가지 핵심 작업인 Embedding Projection과 Prompt Design으로 나뉜다.

4.2.1 Embedding Projection

목적 :

사용자 표현(User Representations)과 공동 임베딩(Joint Collaborative-Text Embedding)을 LLM의 토큰 공간으로 매핑하여 LLM이 이를 입력으로 처리할 수 있도록 한다.

방법 :

두 개의 2-layer MLP를 사용한다.
사용자 표현 $x^u$를 LLM 토큰 공간으로 매핑 : $O_u = F_U(x^u)$
공동 임베딩 $e_i$를 LLM 토큰 공간으로 매핑 : $O_i = F_I(e_i)$
LLM 토큰 공간에서의 사용자 및 아이템 표현으로 매핑된 임베딩은 이후 LLM 입력 프롬프트에 통합된다.

4.2.2 Prompt Design for Integrating Collaborative Knowledge

목적 :

추천 작업에 필요한 협업 지식과 텍스트 정보를 LLM이 활용할 수 있도록 적절한 텍스트 프롬프트를 설계한다.

구성 방식 :

사용자 정보 포함 : 프롬프트 시작 부분에 사용자 표현 $O_u$를 배치하여 개인화된 추천을 수행할 수 있는 기초 정보를 제공한다.
후보 아이템 정보 포함 : 후보 아이템 제목과 함께 매핑된 임베딩 $O_i$를 추가하여, LLM이 사용자의 선호도를 기반으로 아이템을 추천하도록 유도한다.
구조화된 입력 프롬프트 설계 : 사용자 히스토리, 후보 아이템, 그리고 추천 작업에 대한 지시를 포함한 텍스트 프롬프트를 생성한다.

프롬프트 예시 :

5. Experiments

5.1 Experimental Setup

Datasets

Movies and TV : 약 30만 명의 사용자와 6만 개의 아이템으로 구성된 대규모 데이터셋이다.
Video Games : 중간 규모 데이터셋으로, 6만 명의 사용자와 3만 3천 개의 아이템으로 구성된다.
Beauty : 작고 Cold한 데이터셋으로, 9천 명의 사용자와 6천 개의 아이템으로 구성된다.
Toys : 아이템의 수가 사용자 수보다 많은 데이터셋으로, 약 3만 명의 사용자와 6만 개의 아이템을 포함한다.

Baselines

Collaborative Filtering Models : NCF, NextItNet, GRU4Rec, SASRec
Modality-aware Models : MoRec, CTRL, RECFORMER
LLM-based Models : LLM-Only, TALLRec, MLP-LLM

Evaluation Settings

사용자 시퀀스를 Training, Validation, Test 세트로 분리한다.
- 가장 최근에 상호작용한 아이템은 테스트 세트에 포함한다.
- 그 이전 아이템은 검증 세트에 포함한다.
- 나머지 시퀀스는 학습 세트로 사용한다.
Hit@1 평가 지표를 사용한다.

Implementation Details

SASRec을 사전학습된 CF-RecSys로 사용하고, OPT-6.7B를 백본 LLM으로 사용한다.
모델을 효율적으로 학습시키기 위해 하이퍼파라미터를 튜닝한다.

5.2 Performance Comparison

5.2.1 Overall Performance

결과 :

A-LLMRec은 Movies and TV, Video Games, Beauty, 그리고 Toys 데이터를 사용한 실험에서 다른 모든 추천 모델들보다 Hit@1 메트릭 기준으로 우수한 성능을 기록했다.
A-LLMRec은 특히 LLM 기반 모델과 비교할 때, 협업 지식을 효과적으로 활용하여 높은 정확도를 보인다.

5.2.2 Cold/Warm Item Scenario

목적 : Cold 아이템(상호작용 데이터가 적은 아이템)과 Warm 아이템(상호작용 데이터가 풍부한 아이템)을 각각 평가하여 모델의 성능을 분석한다.

결과 :

Cold 시나리오 : A-LLMRec이 다른 모델들보다 뛰어난 정확도를 기록하며 Cold 아이템 추천에서 우수한 성능을 입증한다.
Warm 시나리오 : A-LLMRec은 전통적인 협업 필터링 모델(CF-RecSys)보다도 성능이 우수하여 모든 시나리오에서 높은 추천 품질을 유지한다.

5.2.3 Cold User Scenario

목적 : Cold 사용자를 대상으로 모델의 추천 성능을 평가한다.

결과 : A-LLMRec은 협업 지식과 텍스트 정보를 효과적으로 결합하여 다른 모델 대비 높은 정확도를 유지한다.

5.2.4 Few-shot Training Scenario

목적 : 제한된 학습 데이터를 사용하여 A-LLMRec의 성능을 평가하고 적응력을 분석한다.

결과 : A-LLMRec은 Few-shot 환경에서도 다른 모델들보다 안정적으로 높은 성능을 발휘한다.

5.2.5 Cross-domain Scenario

목적 : 도메인 간 데이터셋을 사용하여 모델의 일반화 능력을 테스트한다.

결과 : A-LLMRec은 도메인 전환 상황에서도 우수한 성능을 유지하여 강력한 확장성을 입증한다.

5.3 Ablation Studies

5.3.1 Stage-1 구성 요소의 영향

실험 목적 : Stage-1에서 각 구성 요소(손실 함수)가 모델 성능에 미치는 영향을 분석한다. 실험 방법 : 각 손실 함수를 제거했을 때의 성능 변화를 관찰한다.

결과 및 분석

$L_{matching}$ 제거 : 모든 데이터셋에서 성능이 크게 감소한다. 이는 아이템과 텍스트 정보 간의 정렬이 효과적이며, LLM이 협업-텍스트 임베딩을 통해 아이템 텍스트 정보를 이해하고 추천 능력을 향상시킬 수 있음을 의미한다.
$L_{item-recon}$ 및 $L_{text-recon}$ 제거 : 성능이 저하된다. 이는 Section 4.1.1에서 논의된 바와 같이 표현이 과도하게 평활화될 위험$(e ≈ q)$ 때문이다.
$L_{rec}$ 제거 : 성능이 저하된다. Lrec는 추천 작업에 대한 정보를 모델에 제공하면서 협업 지식을 명시적으로 통합하기 위해 도입되었으므로, 제거 시 아이템과 사용자 간의 협업 지식이 감소하여 추천 성능이 저하된다.
SBERT 고정 : 모든 데이터셋에서 성능이 저하된다. 이는 SBERT를 fine-tuning하면 텍스트 임베딩이 추천 작업에 더 잘 적응할 수 있음을 의미한다.

5.3.2 Stage-2 정렬 방법의 영향

실험 목적 : Stage-2에서 사용자 표현 및 아이템 임베딩을 LLM 프롬프트에 주입하는 것이 얼마나 효과적인지 검증한다. 실험 방법 : 사용자 표현 또는 joint embedding을 프롬프트에서 제거하거나, joint embedding을 랜덤 임베딩으로 대체했을 때의 성능 변화를 관찰한다.

결과 및 분석

사용자 표현 또는 joint embedding 제거 : 모든 데이터셋에서 성능이 감소한다. 특히 joint embedding을 제거했을 때 성능 감소가 더 큰데, 이는 joint embedding이 협업 지식을 전달하는 데 중요한 역할을 한다는 것을 의미한다. Joint embedding은 아이템에 대한 텍스트 정보도 캡처하므로, 이를 제거하면 성능에 더욱 부정적인 영향을 미친다.
Joint embedding을 랜덤 임베딩으로 대체 : 모든 데이터셋에서 성능이 저하된다. 이는 A-LLMRec가 협업 지식 없이 아이템 임베딩으로 학습될 때 성능이 떨어진다는 것을 의미하며, 추천에 협업 지식을 활용하는 것이 중요하다는 것을 시사한다.

5.4 Model Analysis

5.4.1 Train/Inference Speed

효율성 : A-LLMRec은 CF-RecSys나 LLM의 fine-tuning을 요구하지 않고, alignment network만 훈련하여 효율적으로 작동한다. 반면, TALLRec은 LoRA를 통해 LLM을 fine-tuning해야 한다.
비교 : A-LLMRec과 TALLRec의 훈련 및 추론 시간을 비교한 결과, A-LLMRec이 TALLRec보다 훨씬 빠른 훈련 및 추론 시간을 보인다. 특히 훈련 시간이 크게 개선되었으며, 이는 A-LLMRec이 LLM fine-tuning을 필요로 하지 않기 때문이다.
결론 : A-LLMRec의 높은 효율성은 대규모 추천 데이터셋 및 실시간 추천 서비스에서의 실용성을 보여준다.

5.4.2 Training with all items in each sequence

기본 설정 : Stage-1과 Stage-2의 최종 Loss를 최소화하기 위해 각 사용자 시퀀스의 마지막 아이템만 사용하여 훈련을 진행한다.
실험 방법 : 각 사용자 시퀀스의 모든 아이템을 활용하여 추천 성능을 개선한다.
실험 결과 :
- 모든 아이템을 활용할 경우 Hit@1 지표 기준으로 추천 성능이 개선된다.
- 그러나 훈련 시간이 약 3배 이상 증가했으며, 성능 향상은 상대적으로 미미하다.
결론 : 마지막 아이템만 사용하는 기본 접근 방식이 효율성을 고려할 때 실용적이다.

5.4.3 A-LLMRec is Model-Agnostic

모델 유연성 : A-LLMRec은 SASRec을 기본 CF-RecSys로 사용하되, 다른 CF-RecSys로 대체가 가능하다. NextItNet, GRU4Rec, NCF와 같은 다양한 협업 필터링 모델을 A-LLMRec에 통합하여 테스트를 진행한다.
결과 :
- SASRec을 백본으로 사용할 때 가장 높은 성능을 보여준다.
- A-LLMRec을 기존의 어떤 CF-RecSys에 적용하더라도 성능이 향상된다.
- A-LLMRec은 텍스트 정보와 협업 지식을 결합하여 다양한 CF-RecSys의 성능 격차를 줄인다.

5.4.4 Beyond Recommendation: Language Generation Task

실험 설정 : 사용자의 과거 시청 데이터와 아이템 정보를 기반으로 사용자가 선호하는 영화 장르를 예측하는 언어 생성 태스크를 수행한다.
결과 :
- A-LLMRec은 LLM-Only 모델보다 정확한 답변을 생성한다.
- CF-RecSys의 아이템 임베딩을 LLM의 토큰 공간과 잘 정렬하여 협업 지식을 활용할 수 있도록 지원한다.
- TALLRec은 LLM을 fine-tuning하는 과정에서 자연어 생성 태스크의 성능이 감소하는 문제를 겪는다.

6. Conclusion

A-LLMRec의 제안 :

새로운 LLM 기반 추천 시스템, A-LLMRec를 제안한다.
A-LLMRec은 사전 학습된 CF-RecSys의 협업 지식을 LLM이 활용할 수 있도록 설계되었다.

주요 성과 :

기존 CF-RecSys, 모달리티 기반 추천 시스템, 그리고 LLM 기반 추천 시스템들보다 우수한 성능을 발휘한다.
다양한 시나리오(Cold/Warm Items, Cold User, Few-shot, Cross-domain)에서 효과적이다.

특장점 :

모델 독립성(Model-agnostic) : 기존 CF-RecSys 및 LLM의 fine-tuning이 필요 없다.
효율성(Efficiency) : fine-tuning 없이 간단한 구조로 높은 성능을 발휘한다.

잠재성 :

CF-RecSys에서 얻은 협업 지식을 바탕으로 자연어 생성 작업의 가능성을 확인한다.

향후 작업 :

Chain-of-thought prompt engineering을 활용하여 LLM의 능력을 추가적으로 강화할 계획이다.

[논문] Data-efficient Fine-tuning for LLM-based Recommendation

Fri, 28 Mar 2025 07:35:33 GMT

📄 Paper

Data-efficient Fine-tuning for LLM-based Recommendation [arxiv]

Xinyu Lin ACM SIGIR 24

📝 Key Point

DEALRec 제안 : LLM 기반 추천 시스템을 위한 효율적인 데이터 정제(data pruning) 방법을 제안한다.
핵심 기법 : Influence Score와 Effort Score를 활용해 중요한 샘플을 선택한다.
성능 개선 : 기존 데이터 정제 방법보다 높은 정확도를 유지하면서도 훈련 비용을 94% 이상 절감했다.
일반화 가능성 : 다양한 LLM 추천 모델과 데이터셋에서 일관된 성능 향상을 보였다.

Abstract

문제 제기

최근 LLM을 추천 시스템에 활용하는 연구가 활발히 이루어지고 있다. 그러나 LLM을 빠르게 확장되는 추천 데이터에 맞춰 파인튜닝하는 비용이 실용성에 큰 제한을 둔다.

제안된 해결책

이를 해결하기 위해 'few-shot fine-tuning'이라는 방법을 활용한 LLM의 빠른 적응이 유망한 접근법으로 제시된다. 본 논문에서는 LLM 기반 추천 시스템에서 효율적인 데이터 프루닝(data pruning) 작업을 제안한다. 이 작업은 LLM의 few-shot fine-tuning에 적합한 대표 샘플을 선별하는 과정이다.

기존 방법의 한계

기존의 coreset 선택 방법은 최적이 아닌 휴리스틱 메트릭을 사용하거나, 대규모 추천 데이터에서 비용이 많이 드는 최적화를 요구한다. 이러한 한계를 해결하기 위한 새로운 방법이 필요하다.

목표

데이터 프루닝 작업의 두 가지 주요 목표를 제시한다.

높은 정확도 : 추천 성능을 높일 수 있는 영향력 있는 샘플을 식별하는 것.
높은 효율성 : 데이터 프루닝 과정에서 낮은 비용을 달성하는 것.

제안된 방법

두 가지 목표를 달성하기 위해, influence score와 effort score라는 두 가지 점수를 도입한 새로운 데이터 프루닝 방법을 제안한다.

influence score는 샘플 제거가 전체 성능에 미치는 영향을 정확히 추정하는 데 사용된다.
effort score는 surrogate 모델과 LLM 간의 차이를 고려하여, LLM에 특화된 어려운 샘플을 우선순위로 두는 역할을 한다.

효율성 향상

데이터 프루닝 과정에서 LLM 대신 작은 크기의 대리 모델을 사용하여 영향력 점수를 계산함으로써 비용을 절감한다.

실험 결과

세 가지 실제 데이터셋을 통해 실험을 진행한 결과, 제안한 방법은 전체 데이터를 사용한 파인튜닝을 초과하는 성능을 보였으며, 시간 비용을 97%까지 절감하는 성과를 얻었다.

Figure

DEALRec의 구조

전체 학습 샘플에서 Surrogate Model을 학습시킨다.
influence score를 계산한다.
effort score로 influence score를 정규화하여 영향력 있는 샘플을 식별한다.

1. Introduction

LLM 기반 추천 시스템의 필요성

LLM을 활용한 추천 시스템은 다양한 작업에서 유망한 성과를 보였다. 추천 데이터는 빠르게 업데이트되기 때문에 LLM을 자주 파인튜닝해야 하며, 이는 사용자 행동과 최신 아이템 정보를 반영하는 데 필수적이다.

파인튜닝의 도전 과제

대규모 추천 데이터를 파인튜닝하는 데는 두 가지 주요 문제가 존재한다.

정확도 : 모든 훈련 샘플을 평가해야 하며, 이는 비용이 많이 든다.
효율성 : 효율적인 샘플 선택을 통해 훈련 시간과 비용을 절감해야 한다. 랜덤 샘플링된 데이터는 충분한 대표성을 가지지 못할 가능성이 높다.

DEALRec 방법 제안

이를 해결하기 위해 DEALRec이라는 데이터 프루닝 방법을 제안한다. DEALRec는 두 가지 점수를 사용하여 효율적으로 샘플을 선택한다.

influence score : 각 샘플을 제거할 때 실험적 위험에 미치는 영향을 추정한다.
effort score : 샘플 loss에 대한 gradient norm을 계산하여, LLM이 해당 샘플을 학습하는 데 드는 effort을 측정한다.

DEALRec의 장점

DEALRec는 influence score와 effort score를 결합하여, LLM의 파인튜닝을 위한 중요한 샘플을 효율적으로 선택한다. 기존의 방법들은 비용이 많이 들거나 실용성이 떨어지지만, DEALRec는 더 정확하고 효율적인 샘플 선택을 가능하게 한다.

실험 결과

DEALRec는 두 개의 LLM 기반 추천 모델에 적용되었으며, 세 가지 실제 데이터셋에서 우수한 효율성과 정확성을 입증하였다. DEALRec는 시간 비용을 절감하면서도 우수한 성능을 보였다.

기여

LLM 기반 추천 시스템에서 데이터 프루닝 작업을 도입하여 실제 플랫폼에 적용 가능성을 높였다.
LLM 기반 추천을 위한 효율적이고 정확한 데이터 프루닝 방법을 제안했다.
세 가지 실제 데이터셋에서 DEALRec의 우수성을 실험적으로 입증하였다.

2. Task Formulation

LLM 기반 추천 모델

LLM을 추천 시스템에 활용하려면, LLM을 직접 추천 모델로 사용하는 것이 일반적이다. 하지만 LLM은 추천 데이터를 기반으로 학습되지 않았기 때문에, 아이템 지식을 학습하고 사용자 행동을 이해하기 위해 fine-tuning이 필수적이다. 훈련 샘플은 사용자 시퀀스로 표현되며, 이는 사용자의 역사적 상호작용 순서와 다음 상호작용 아이템을 포함한다. 이를 기반으로 LLM의 학습 파라미터를 최적화하기 위해 음의 로그 우도 함수를 최소화하는 방식으로 fine-tuning을 진행한다.

하지만 LLM을 fine-tuning하는 데는 많은 자원과 시간이 소모되며, 추천 데이터는 지속적으로 갱신되므로 LLM 기반 추천 시스템의 실제 적용에 어려움이 있다. 따라서 LLM 기반 추천 시스템의 효율성을 높이는 것이 중요하다.

효율적인 LLM 기반 추천을 위한 데이터 절단

효율적인 LLM 기반 추천을 달성하기 위해, 무작위로 샘플을 선택하여 몇 가지 샷으로 fine-tuning을 하는 방식이 유망하다. 그러나 무작위 샘플은 최신 사용자 행동이나 아이템 정보를 충분히 반영하지 못할 가능성이 높다. 따라서 LLM의 몇 가지 샷 fine-tuning을 위한 대표 샘플을 선택하는 데이터 절단 작업이 필요하다.

이 작업의 목표는 전체 훈련 샘플 중에서 효율적으로 샘플을 선택하여 LLM이 테스트 세트에서 좋은 성능을 낼 수 있도록 하는 것이다. 선택된 샘플의 크기는 주어진 선택 비율에 의해 제어된다.

Coreset Selection

데이터 절단 작업과 관련된 연구로, coreset 선택 방법이 있다. coreset 선택 방법은 크게 두 가지로 나눠진다.

휴리스틱 방법 : 경험적 최소화 전략을 기반으로 샘플을 선택하는 방법이다. 예를 들어, 예측 엔트로피가 큰 샘플을 선택하거나 샘플 표현을 기반으로 클러스터링을 할 수 있다. 그러나 이러한 방법은 샘플이 실험적 위험에 미치는 영향을 명시적으로 고려하지 않아, 선택된 샘플로 훈련한 모델의 성능이 최적이 아닐 수 있다.
최적화 기반 방법 : 이 방법은 이층 최적화 기법을 사용하여 훈련할 최적의 샘플 집합을 선택하는 방식이다. 그러나 이 방법은 대규모 데이터셋에 적용하기 어렵고, 최적화 문제를 풀기 위한 계산이 복잡하여 LLM 기반 추천 모델에 적합하지 않다.

이전의 coreset 선택 방법들은 보통 원본 훈련 샘플에서 모델을 훈련해야 하는데, 이는 LLM 기반 추천 모델에서 데이터가 계속해서 유입되고 자원 비용이 크기 때문에 현실적으로 불가능하다.

데이터 절단 목표

높은 정확도 : 선택된 샘플로 훈련한 모델이 낮은 실험적 위험을 가지는 것을 목표로 한다.
높은 효율성 : 데이터 절단 과정에서 비용을 최소화하고, LLM의 무거운 fine-tuning을 피하는 것을 목표로 한다.

3. DEALRec

DEALRec는 효율적인 LLM 기반 추천 시스템을 위한 데이터 절단 방법이다. 이 방법은 두 가지 주요 요소를 포함한다.

Influence Score : 경험적 위험에 대한 영향을 추정하기 위한 점수
Effort Score : LLM과 대체 모델 간의 학습 능력 차이를 보완하기 위한 정규화 요소

3.1 Influence Score

파라미터 변화에 대한 영향 : 샘플을 upweight할 때의 파라미터 변화는 influence function를 사용해 추정된다. 이때 계산은 비용이 많이 드는 방식이지만, 체인 룰과 이차 최적화 기법을 활용해 효율적으로 근사된다.
경험적 위험에 대한 영향 : 샘플 제거가 경험적 위험에 미치는 영향을 추정하는 방법이다. 이를 통해 각 샘플의 influence score를 계산할 수 있다.
효율적인 influence score 계산 : Hessian-Vector Products (HVP)를 사용하여 계산을 효율적으로 만든다. 이를 통해 모든 샘플에 대한 influence score를 한 번의 계산으로 추정할 수 있다.

3.2 Gap Regularization

Surrogate Model (대체 모델) : 계산 비용을 줄이기 위해 작은 크기의 전통적인 추천 모델을 사용한다. 그러나 LLM은 사전 훈련을 통해 풍부한 지식을 얻기 때문에 대체 모델과는 학습 능력에서 차이가 있다.
Effort Score : LLM이 특정 사용자 시퀀스를 학습하는 데 드는 effort를 측정한다. 큰 점수는 LLM이 학습하기 어려운 샘플을 나타낸다. 이 점수는 LLM의 학습 능력 차이를 보완한다.
전체 점수 : influence score와 effort score를 결합하여 최종 점수를 계산한다. 이를 통해 LLM 기반 추천 시스템의 효율적인 fine-tuning을 할 수 있다.

3.3 Few-shot Fine-tuning

데이터 선택 : 최종 점수를 기반으로 데이터를 선택하여 LLM을 적은 양의 데이터로 fine-tuning 한다.
문제 : 높은 점수를 가진 샘플을 선택하면 유사한 샘플들이 중복되므로 전체적인 성능 향상에 한계가 있다.
해결 방법 : 계층화 샘플링(stratified sampling)을 사용하여 다양한 영역에서 균등하게 샘플을 선택하고, 데이터 커버리지를 향상시킨다.

DEALRec는 influence score와 effort score를 결합하여 LLM 기반 추천 모델의 fine-tuning을 효율적으로 개선하는 방법을 제시한다.

4. Experiment

RQ1 : DEALRec이 기존의 coreset 선택 기법 및 전체 데이터 학습 모델과 비교하여 얼마나 우수한가?
RQ2 : DEALRec의 주요 구성 요소(영향 점수, 간극 정규화, 층화 샘플링)의 효과는 어떠하며, 다른 대체 모델에도 일반화될 수 있는가?
RQ3 : 샘플링 비율에 따른 DEALRec의 성능 변화는 어떠하며, 전반적인 성능을 얼마나 향상시키는가?

4.1 실험 설정

1) 데이터셋

Games(Amazon 리뷰 데이터셋, 비디오 게임 추천)
MicroLens-50K(마이크로 비디오 추천)
Book(Amazon 리뷰 데이터셋, 도서 추천)
사용자-아이템 상호작용 데이터를 시간순으로 정렬 후 8:1:1 비율로 훈련, 검증, 테스트 데이터셋으로 분할
두 가지 미세 조정 방식 적용
- Few-shot fine-tuning(1024개 샘플, 다양한 데이터 선택 기법 적용)
- Full fine-tuning(전체 데이터 활용)

2) 비교 기법(베이스라인)

무작위 샘플링(Random): 무작위 데이터 선택
난이도 기반 방법(GraNd, EL2N): 그래디언트 크기 및 예측 오류를 기준으로 어려운 샘플 선택
다양성 기반 방법(TF-DCon, RecRanker): 사용자 시퀀스를 다양하게 구성
CCS: 높은 데이터 커버리지와 중요도를 고려한 샘플 선택
LLM 기반 추천 모델: BIGRec(LLaMA-7B 활용), TIGER(아이템 특성 학습 후 토큰 변환)

3) 평가 지표

Recall@K, NDCG@K 사용 (K=10, 20, 50)

4) 실험 환경

BIGRec은 LLaMA-7B, TIGER는 Transformer 기반
4개의 NVIDIA RTX A5000 GPU 사용
LoRA 기법으로 BIGRec을 미세 조정, TIGER는 전체 파라미터 미세 조정
DEALRec의 대체 모델로 SASRec 사용

4.2 전체 성능 분석(RQ1)

BIGRec이 TIGER보다 일반적으로 우수한 성능을 보이며, 이는 LLaMA-7B의 강력한 일반화 성능과 아이템 제목 활용 때문일 가능성이 높다.
난이도 기반 방법(GraNd, EL2N)이 다양성 기반 방법(TF-DCon, RecRanker)보다 성능이 높다.
무작위 샘플링이 일부 coreset 선택 방법보다 성능이 높으며, 이는 데이터 분포를 균일하게 유지하기 때문일 가능성이 높다.
DEALRec이 모든 비교 기법보다 우수한 성능을 보이며, 영향 점수와 간극 정규화를 통해 LLM 적응을 효과적으로 수행한 것으로 판단된다.
DEALRec은 전체 데이터를 학습한 모델보다도 성능이 높으며, 학습 비용을 평균 97.11% 절감할 수 있다.

4.3 심층 분석

1) 구성 요소별 효과 분석(RQ2)

영향 점수 또는 간극 정규화를 제거하면 성능이 저하됨
탐욕적 샘플 선택(가장 높은 점수 샘플만 선택)은 성능이 떨어짐

2) 대체 모델에서의 일반화 성능(RQ2)

DEALRec은 다른 추천 모델(BERT4Rec, SASRec, DCRec)에서도 우수한 성능을 보이며, 일반화 가능성이 높다.
SASRec이 학습 시간이 가장 짧고 안정적인 성능을 보이며, 실무 적용에 적합할 가능성이 높다.

3) 샘플링 비율에 따른 성능 변화(RQ3)

샘플링 비율(𝑟)이 1%까지 증가할 때 성능이 급격히 향상되며, 이후 추가 샘플 증가에 따른 성능 향상은 미미하다.
1% 샘플링이 전체 데이터 학습과 유사한 성능을 내면서도 94% 이상의 학습 비용 절감 효과를 보인다.

4) 사용자 그룹별 성능 분석(RQ3)

난이도가 높은 사용자 그룹에서 전반적으로 성능이 감소하지만, DEALRec이 무작위 샘플링보다 일관되게 우수한 성능을 보인다.

5) 정규화 강도(𝜆)에 따른 성능 변화

𝜆가 증가함에 따라 성능이 향상되지만, 너무 높은 𝜆는 오히려 성능 저하를 초래할 가능성이 있다.
영향 점수와 LLM 학습 능력 간의 균형을 맞추는 것이 중요하다.

6. Conclusion

본 연구에서는 LLM 기반 추천 시스템의 효율적인 데이터 정제를 위한 작업을 제안하였으며, 이는 LLM의 few-shot fine-tuning을 위한 대표적인 샘플을 식별하는 것을 목표로 한다. 이를 위해 데이터 정제 작업에서 두 가지 주요 목표를 설정하였다.

높은 정확도 : 실험적 위험(empirical risk)이 낮아질 가능성이 높은 샘플을 선택하는 것을 목표로 한다.
높은 효율성 : 데이터 정제 과정에서 비용을 절감하는 것을 목표로 한다.

이러한 목표를 달성하기 위해 DEALRec이라는 새로운 데이터 정제 방법을 제안하였다.

Influence Score : 샘플 제거가 실험적 위험에 미치는 영향을 추정하며, 영향 함수에서 확장된 형태로 대칭 속성을 활용하여 가속화하였다.
대체 모델(Surrogate Model) 활용 : 소형 대체 모델을 사용하여 영향 점수를 효율적으로 계산하고, LLM과의 격차를 줄이기 위해 Effort Score를 도입하였다.

실험 결과, DEALRec이 높은 효율성과 높은 정확도를 동시에 달성할 가능성이 높음을 검증하였다.

본 연구는 LLM 미세 조정을 위한 데이터 정제 작업을 제안함으로써 새로운 연구 방향을 개척하였으며, 향후 연구에 대한 여러 가능성을 남겼다.

DEALRec을 다양한 LLM 기반 추천 모델과 교차 도메인 데이터셋에 적용하여 제한된 자원으로도 미세 조정 성능을 향상시킬 가능성이 높다.
LLM의 제한적인 컨텍스트 윈도우 길이를 고려할 때, 사용자 상호작용 데이터에서 정보량이 높은 항목을 선택하여 미세 조정 성능을 개선할 가능성이 높다.
LLM 기반 추천 모델의 추론 효율성을 향상시키는 것이 실제 적용을 위해 중요한 문제로 남아 있을 가능성이 높다.

[논문] Sequential Recommendation with Latent Relations based on Large Language Model

Thu, 27 Mar 2025 09:14:15 GMT

📄 Paper

Sequential Recommendation with Latent Relations based on Large Language Model [arxiv]

Shenghao Yang ACM SIGIR 24

📝 Key Point

LRD (Latent Relation Discovery) 제안 : LLM을 기반으로 한 새로운 방법인 LRD는 잠재적인 아이템 관계를 효과적으로 발견하는 방법이다. 이를 통해 기존의 관계 인식 순차 추천 시스템을 향상시킬 수 있다.
자기 지도 학습 활용 : LRD는 자기 지도 학습 접근 방식을 사용하여, LLM이 제공하는 풍부한 지식을 바탕으로 아이템 간의 잠재적 관계를 추출한다.
잠재 관계와 사용자 상호작용 신호 : LRD는 사용자 상호작용 신호를 통해 관계 발견 과정을 효과적으로 안내하며, 발견된 잠재 관계는 신뢰할 수 있음을 추가 분석을 통해 확인할 수 있다.

Abstract

연구 배경

순차 추천 시스템은 사용자의 과거 행동을 기반으로 관심 아이템을 예측하는 방식이다. 기존 방법은 아이템 간 암묵적 협업 필터링 신호를 활용하며, 관계 기반 모델은 지식 그래프에서 아이템 관계를 추출하여 성능을 향상시킨다. 그러나 사전 정의된 관계에 의존하고 데이터 희소성 문제가 있어 일반화에 한계가 있다.

연구 목표

본 연구는 사전 정의된 관계 없이 LLM을 활용하여 아이템 간 잠재적 관계를 학습하는 Latent Relation Discovery (LRD) 기법을 제안한다.

제안 기법 (LRD)

LLM을 활용하여 아이템 간 자연어 기반 관계 표현을 생성하고, 이를 DVAE (Discrete state Variational AutoEncoder)로 학습한다. 자기 지도 학습을 적용하여 관계 학습과 추천을 동시에 최적화한다.

실험 결과

여러 공개 데이터셋 실험에서 LRD는 기존 관계 기반 모델과 결합하여 추천 성능을 크게 향상시켰다. 희소성 문제를 완화하고, 추천 품질을 개선하는 데 효과적이다. 추가 분석을 통해 LLM이 학습한 관계가 신뢰할 수 있음을 확인하였다.

Figure

LRD 기반 관계 인식 순차 추천 프레임워크

LRD는 두 가지 주요 구성 요소로 이루어져 있다.

관계 추출 모델 (Relation Extraction Model)
- LLM을 활용하여 아이템의 언어 기반 지식 표현을 생성한다.
- 이를 바탕으로 두 아이템 간 잠재적 관계을 추정한다.
아이템 재구성 모델 (Item Reconstruction Model)
- 추정된 관계와 다른 아이템을 기반으로 대상 아이템을 재구성한다.

이 과정에서 지식 그래프의 사전 정의된 관계와 LRD에서 추론한 잠재 관계를 함께 활용하여 추천 성능을 향상시킨다.

1. Introduction

연구 배경

순차 추천 시스템은 사용자의 과거 행동을 기반으로 다음에 선호할 아이템을 예측하는 기술이다. 초기에는 마르코프 체인을 활용했으며, 이후 RNN, CNN, Transformer 등의 딥러닝 모델이 도입되면서 성능이 향상되었다. 그러나 대부분의 기존 모델은 아이템 간 암묵적 유사성을 계산하는 협업 필터링 방식에 의존하며, 명시적인 관계를 고려하지 않는다. 최근 관계 기반 순차 추천 모델이 등장했으나 한계가 있다.

기존 접근법의 문제점

기존 관계 기반 추천 모델은 지식 그래프를 활용하지만 두 가지 희소성 문제를 가진다.

관계 희소성 : 대부분의 관계는 수동으로 정의되며, 실제로 존재하는 다양한 관계를 충분히 반영하지 못한다.
아이템 희소성 : 협업 필터링 기반 관계는 충분한 사용자 데이터가 필요하지만, 데이터가 부족한 경우 일반화가 어렵다.

이를 해결하기 위해 아이템 간 잠재적 관계를 자동으로 발견하는 방법을 연구한다.

연구 목표 및 제안 기법

본 연구에서는 LLM을 활용한 Latent Relation Discovery (LRD) 기법을 제안한다.

LLM이 아이템 간 언어 기반 관계 표현을 학습하도록 하고, 자기 지도 학습을 적용하여 잠재 관계를 학습한다.
기존 관계 기반 추천 모델과 결합하여 추천 성능을 향상시킨다.

LRD의 특징 및 장점

수동 정의 없이 관계를 자동으로 발견하여 다양한 사용자 선호를 반영한다.
추천 최적화 과정에서 관계 학습을 함께 수행하여 유용한 관계를 효과적으로 발견한다.
아이템 간 관계 분석을 통해 추천 모델의 해석 가능성을 높인다.

실험 및 성능 검증

공개 데이터셋 실험 결과, LRD는 기존 관계 기반 추천 모델보다 성능이 우수했다.

LLM을 활용한 잠재 관계 학습으로 사용자 시퀀스 표현이 더 풍부해졌다.
추가 실험을 통해 LRD가 합리적인 관계를 효과적으로 학습할 수 있음을 확인했다.

연구 기여

LLM을 활용하여 잠재적 관계를 자동으로 학습하는 순차 추천 기법을 최초로 제안했다.
자기 지도 학습 기반의 LRD 프레임워크를 설계하여 기존 관계 기반 추천 모델과 쉽게 결합할 수 있도록 했다.
여러 데이터셋 실험을 통해 기존 모델 대비 추천 성능 향상을 검증했다.

2. Problem Statement

기호 정의

사용자 집합($U$) 및 아이템 집합($V$) 을 정의한다.
사용자 $u \in U$ 의 시간순 상호작용 기록은 $S_u = {v_1, v_2, v_3, ..., v_{N_u} }$ 로 표현된다.
특정 아이템 $v_i \in V$ 에 대해, 관계 $r$ 를 가진 또 다른 관련 아이템 $v_{-i}$ 가 존재할 수 있으며, 이는 삼중항(triplet) $(v_i, v_{-i}, r)$ 로 나타낸다.
관계 집합($R$) 은 사전 정의된 관계 집합 $R_{def}$ 과 잠재적 관계 집합 $R_{latent}$ 으로 나뉜다.
지식 그래프($G$) 는 사전 정의된 관계를 포함한 아이템 관계 삼중항 집합 $T$ 을 저장한다.
- Vertex 집합은 모든 관계를 가진 아이템 쌍으로 구성된다.
- Edge 집합은 사전 정의된 관계들로 구성된다.

순차 추천 문제 정의

목표 : 사용자 $u$ 의 과거 상호작용 기록 $S_u$ 를 고려하여, 다음 상호작용 시 추천할 아이템을 순위별로 제공하는 것이다.
관계 기반 순차 추천 : 기존 방법은 아이템 간 관계 중 $R_{def}$ 만을 활용하지만, 제안하는 LRD(Latent Relation Discovery) 는 잠재적 관계 집합 $R_{latent}$ 을 추가적으로 활용 하여 추천 성능을 개선한다.

3 Method

3.1 Framework Overview

연구에서 제안하는 관계 인식 순차 추천 프레임워크의 핵심 구성 요소는 잠재 관계 발견 모듈이다. 이 모듈은 Discrete-state Variational Autoencoder (DVAE)에서 영감을 얻은 자기 지도 학습 방식으로 설계되었다.

잠재 관계 발견 모델은 두 개의 하위 모듈로 구성된다.

관계 추출 모듈 : LLM을 활용하여 아이템의 언어 지식 표현을 얻고, 이를 바탕으로 두 아이템 간의 잠재 관계를 예측한다.
아이템 재구성 모듈 : 예측된 잠재 관계와 하나의 아이템 표현을 이용하여 다른 아이템을 재구성한다.

이 모듈을 관계 인식 순차 추천 모델에 통합하여, 사용자 선호도를 보다 정교하게 모델링할 수 있도록 한다. 또한 추천 작업의 목표를 이용하여 더 유용한 관계를 발견하도록 유도한다.

DVAE (Discrete-state Variational Autoencoder)

논문 "Discrete-State Variational Autoencoders for Joint Discovery and Factorization of Relations" 에서 제안된 Discrete-state Variational Autoencoder (DVAE) 는 이산적인(discrete) 관계 표현을 학습하는 확률 생성 모델이다. DVAE는 연속적인 잠재 공간을 가지는 일반적인 VAE와 달리, 이산적인 잠재 변수를 사용 한다. 이를 통해, 복잡한 관계 데이터를 명확한 상태(state)로 분해(factorization) 하고, 각 관계를 효과적으로 학습 할 수 있다. DVAE는 특히 관계 추론(Relation Inference) 과 지식 그래프(Knowledge Graph, KG) 학습 에 적용될 수 있으며, 다음과 같은 특징을 가진다.

이산적인 관계 표현 학습 : 연속적인 잠재 변수를 사용하지 않고, 관계를 이산적인 잠재 변수로 모델링한다.
관계 발견(Joint Discovery) 및 분해(Factorization) : DVAE는 새로운 관계를 자동으로 발견하고, 기존 관계를 더 작은 구성 요소로 분해하여 학습할 수 있다.
VAE 프레임워크 기반 : 확률 모델의 구조는 Variational Autoencoder (VAE) 를 따르며, 잠재 변수 $z$를 통해 데이터 $x$를 생성하는 방식이다.

3.2 Latent Relation Discovery (LRD)

3.2.1 Optimization Objective

잠재 관계는 수동으로 구축된 관계 데이터셋에 포함되지 않은 관계이므로, 지도 학습이 아닌 자기 지도 학습 방식을 사용한다. DVAE 기반 접근법을 따르며, 모든 관계가 균등한 분포를 따른다고 가정한다. 이를 바탕으로 pseudo-likelihood 최적화 목표를 설정한다.

이를 변분 후 조건부 확률을 적용하여 최적화 함수로 변환한다.

관계 추출 모델 $q(r|v_i, v_{−i}, ψ)$ 를 통해 두 아이템 간 관계를 예측한다.
아이템 재구성 모델 $p(v_i | v_{−i}, r, θ)$ 를 통해 예측된 관계와 다른 아이템을 이용하여 원본 아이템을 재구성한다.
엔트로피 항($H$)을 추가하여 관계 예측의 균형을 조정한다.

Pseudo-Likelihood

Pseudo-Likelihood 는 완전한 우도(likelihood)를 직접 계산하기 어려운 경우, 개별 변수의 조건부 확률을 곱하여 근사하는 방법이다. $PL(X) = \prod_{i=1}^{n} P(x_i | X_{\backslash i})$ 즉, 전체 확률을 직접 계산하는 대신, 각 변수의 조건부 확률들의 곱으로 근사한다. 확률 모델에서 우도를 직접 계산하기 어려운 경우, Pseudo-Likelihood를 사용해 계산량을 줄이고 학습이 가능하도록 만든다.

장점 :
- 계산이 효율적이고 대규모 확률 모델에서도 사용 가능
- Markov Random Field(MRF), Conditional Random Field(CRF) 같은 그래픽 모델에서 학습 가능
- 정규화 상수를 계산할 필요 없음
한계 :
- 변수 간의 강한 상관관계를 잘 반영하지 못할 수 있음
- 샘플링 기반 방법(MCMC)보다 정확도가 낮을 수도 있음
- 독립 가정이 강해 일부 데이터 구조에서는 성능이 떨어질 수 있음
응용 분야:
- Markov Random Field (MRF), Conditional Random Field (CRF)
- NLP (개체명 인식, POS 태깅)
- Energy-Based Models (EBMs)

변분 (Variational)

변분은 함수 자체를 최적화하는 방법으로, 함수 공간에서 최적의 해를 찾는 과정이다.

일반 최적화는 수치를 찾지만, 변분은 함수를 최적화하는 과정
물리학, 머신러닝 등 다양한 분야에서 활용됨
주요 활용 예시
- 변분 미적분 : 최소 작용 원리 등 최적 경로 찾기
- 변분 추론 (VI) : 복잡한 확률 분포를 단순한 분포로 근사
- 변분 오토인코더 (VAE) : 잠재 변수 분포를 학습해 이미지 생성 등 활용

3.2.2 Relation Extraction

관계 추출 모델의 목표는 주어진 두 아이템 간의 잠재 관계를 예측하는 것이다.

기존 연구에서 속성 기반 관계는 수집이 비교적 용이하지만, 현실 세계에서는 복잡하고 다양한 관계가 존재하여 수동 정의가 어렵다.
LLM이 언어적 지식을 통해 인간처럼 관계를 설명할 수 있다는 점에 착안하여, 아이템의 언어 지식 표현을 기반으로 관계를 추출하는 방식을 도입한다.
LLM을 사용하여 아이템 텍스트의 토큰 시퀀스를 입력하고, 풀링(e.g. CLS-pooling, mean-pooling)을 적용하여 언어 지식 표현(language knowledge representation)을 얻는다.

이를 바탕으로, 관계 추출 모델은 경량 선형 분류기(softmax 기반)를 사용하여 관계를 예측한다.

Pooling

Pooling은 주로 컨볼루션 신경망(CNN)에서 사용되는 기법으로, 입력 데이터를 다운샘플링하여 중요한 특징만 추출하고 계산량을 줄이는 역할을 한다. 보통 이미지나 시퀀스 데이터를 처리할 때, 데이터의 크기를 줄이면서도 중요한 정보를 유지하려고 사용된다.

특징 추출 : 데이터에서 중요한 특징을 강조한다.
계산 효율성 : 데이터 크기를 줄여 계산량 감소시킨다.
과적합 방지 : 데이터의 세부적인 부분을 무시하고, 일반화된 특성만을 사용한다.

NLP에서 쓰이는 Pooling 기법은 문자, 단어, 또는 문서 수준에서 중요한 정보를 추출하기 위해 사용된다. NLP에서는 주로 단어 임베딩이나 문장의 임베딩을 처리할 때 Pooling 기법을 적용한다. 이 기법은 단어 수준의 임베딩을 하나의 고차원 벡터로 요약하는 데 유용하다.

3.2.3 Relational Item Reconstruction

관계 추출 모델을 통해 두 아이템 간의 잠재 관계를 추정한 후, 이를 기반으로 아이템 재구성 모델을 통해 아이템을 재구성한다.

아이템 재구성 과정에서는 DistMult를 사용하여 관계 임베딩을 적용한다.
모든 아이템을 고려하는 계산 복잡도를 줄이기 위해 네거티브 샘플링(negative sampling) 기법을 사용하여 최적화한다.

DisMult

DisMult는 지식 그래프 및 추천 시스템에서 관계 추론을 위한 모델로, 주어진 triple (head, relation, tail)에 대해 관계를 예측하는 방법이다. head 엔티티와 tail 엔티티의 벡터를 내적하여 관계를 예측한다. DisMult는 보통 관계형 데이터를 다룰 때 주로 사용되며, 특히 지식 그래프에서의 링크 예측(Link Prediction) 작업에 활용된다.

임베딩 기반 : DisMult는 각 엔티티와 관계를 벡터로 표현하고, 이를 통해 관계를 모델링한다.
내적 사용 : 모델은 관계 벡터와 엔티티 벡터 간의 내적을 계산하여 트리플의 가능성을 예측한다.
대칭성 가정 : DisMult는 모든 관계가 대칭적이라고 가정하고, 이를 통해 모델을 단순화한다.

3.3 LRD-based Sequential Recommendation

3.3.1 Relation-aware Sequential Recommendation

사용자의 과거 인터랙션 정보를 기반으로 선호도를 모델링하며, 아이템 간의 관계를 명시적으로 고려하여 더욱 정교한 추천이 가능하도록 한다.

사용자 u의 선호도 점수는 $y_{u,j} = (u + m_{u,j}) v_j^T + b_j$ 로 정의된다.
여기서 $m_{u,j}$는 사용자의 과거 기록과 타겟 아이템 간의 관계를 고려한 사용자 이력 표현이다.
$m_{u,j}$는 여러 관계 유형에 따른 사용자 시퀀스 표현을 집계(aggregation)하여 생성하며, 평균 풀링(mean-pooling), 최대 풀링(max-pooling), 어텐션 풀링(attention-pooling) 등의 방법을 사용할 수 있다.
관계의 강도를 고려하여 가중치를 적용하는 방식으로 아이템 표현을 구성한다.

3.3.2 Joint Learning

관계 인식 순차 추천 모델을 최적화하기 위해 BPR(Bayesian Personalized Ranking) pairwise loss를 사용한다.

잠재 관계 발견(LRD)과 추천 모델을 동시에 학습(joint optimization)한다.
이를 통해 추천 작업이 잠재 관계 발견을 돕도록 하고, 발견된 관계가 추천 성능 향상에 기여하도록 한다.
이를 위해 LRD의 최적화 목표를 추천 모델의 최적화 목표에 통합하여 함께 학습한다.

BPR pairwise loss

BPR (Bayesian Personalized Ranking) Pairwise Loss는 추천 시스템에서 사용자에게 아이템을 추천할 때 순위(rank)를 예측하기 위한 손실 함수이다. 주로 implicit feedback(사용자의 클릭, 구매 등) 데이터를 다룰 때 사용된다. BPR은 pairwise ranking 방식을 사용하여 두 아이템 간의 상대적 순위를 학습한다.

Pairwise Ranking : BPR은 사용자와 관련된 두 아이템을 비교하며, 사용자가 특정 아이템을 선호하는지 여부를 학습한다.
Loss Function : 손실 함수는 두 아이템을 비교하여, 사용자가 한 아이템을 선호하고 다른 아이템을 선호하지 않는 방식으로 학습한다. $ L = -\sum_{(u, i, j) \in D} \log \sigma(\hat{r}{ui} - \hat{r}{uj}) $
임베딩 기반 : BPR은 사용자와 아이템을 임베딩 공간에 매핑하고, 해당 공간에서의 상대적인 거리를 학습한다.
순위 학습 : BPR은 아이템의 절대적인 점수가 아닌 상대적인 순위에 집중하여 학습한다.

4. Experiments

RQ1 : LRD 강화된 관계 인식 순차 추천 모델의 효과는 무엇인가?
RQ2 : LRD 강화된 관계 인식 순차 추천 모델의 각 구성 요소가 추천 성능에 기여하는가?
RQ3 : LRD가 아이템 간 신뢰할 수 있는 중요한 관계를 발견하는가?

4.1 실험 설정

4.1.1 데이터셋

모델의 잠재적 관계 발견 능력을 평가하기 위해 세 가지 공개 데이터셋을 사용한다.

MovieLens : 영화 추천을 위한 데이터셋으로, 사전 정의된 관계(출시 연도, 장르)와 IMDB에서 추가로 크롤링한 영화 정보로 잠재적 관계를 발견한다.
Amazon Office 제품 및 전자제품 : 아마존 전자상거래 데이터셋의 두 하위집합으로, 사전 정의된 관계(카테고리, 브랜드)와 아이템 제목, 카테고리, 브랜드를 통해 잠재적 관계를 발견한다.

4.1.2 비교 모델

여러 가지 순차 추천 모델이 비교 모델로 사용된다.

Caser : convolutional 필터를 사용하여 사용자 시퀀스의 순차적 패턴을 포착하는 모델이다.
GRU4Rec : Gated Recurrent Units(GRU)를 활용하여 사용자 상호작용 시퀀스의 패턴을 학습하고 사용자 표현을 모델링하는 방식이다.
SASRec : self-attention 메커니즘을 도입하여 과거 항목의 표현을 통합하고 사용자 표현을 학습한다.
TiSASRec : SASRec을 기반으로 하며, 과거 상호작용 간의 시간 간격을 추가로 고려하는 방식이다.
RCF : 두 단계로 이루어진 attention 네트워크를 활용하여 아이템 간 관계를 사용자 시퀀스 표현 모델링에 통합한다.
KDA : 푸리에 변환 기반의 시간적 진화 모듈을 도입하여 아이템 관계의 동적 변화를 효과적으로 포착하는 모델이다.

제안된 LRD 방법은 RCF와 KDA 모델을 향상시켜 RCFLRD와 KDALRD를 비교 모델로 사용한다.

4.1.3 평가 지표

추천 모델 성능을 평가하기 위해 HR@K와 nDCG@K 지표를 사용하며, K는 5와 10으로 설정된다. 데이터셋은 leave-one-out 방식으로 구성하고, 다섯 번의 랜덤 실행을 통해 평균 지표를 평가한다.

leave-one-out

Leave-One-Out은 교차 검증의 한 종류로, 주로 모델의 성능을 평가할 때 사용된다. 이 방법은 주어진 데이터셋에서 각 샘플을 하나씩 제외하고, 나머지 데이터로 모델을 학습하여 그 샘플에 대한 예측을 평가하는 방식이다. 특히 데이터가 적거나 성능을 정확하게 평가하고 싶을 때 유용하게 사용된다.

각 샘플을 한 번씩 테스트 데이터로 사용 : 각 샘플이 한 번은 모델의 테스트에 사용되므로, 모델이 모든 샘플에 대해 평가된다.
완전한 검증 : 모든 데이터가 훈련과 테스트에 사용되므로 모델에 대한 신뢰성을 높일 수 있다.
과적합 방지 : 모델이 훈련 데이터에 너무 적합되는 것을 방지하는 데 도움이 된다.
소규모 데이터셋에 유용 : 데이터셋이 작을 때, 가능한 모든 데이터를 테스트에 활용할 수 있어 효과적이다.
시간 소모 : 데이터셋의 크기가 커지면, 모든 샘플을 하나씩 제외하고 학습 및 예측을 반복해야 하므로 계산 비용이 많이 든다.

4.1.4 구현 세부사항

LRD와 비교 모델은 ReChorus 라이브러리로 구현되며, 아이템의 언어 지식 표현을 얻기 위해 GPT-3을 사용한다. 여러가지 하이퍼파라미터를 튜닝하였고, 관계 추출 모델의 정규화 계수는 0.1로 설정된다.

4.2 성능 비교 (RQ1)

실험 결과 :

전통적인 순차 추천 모델은 MovieLens와 같은 밀집된 데이터셋에서는 성능 차이가 크지 않지만, 아마존과 같은 희소한 데이터셋에서는 성능이 저조하다.
아이템 관계를 포함한 RCF와 KDA 모델은 전통적인 모델보다 우수한 성능을 보인다.
LRD를 강화한 RCFLRD와 KDALRD는 사전 정의된 관계가 적은 데이터셋에서 더 높은 성능을 발휘하며, 잠재적 관계를 발견하여 성능을 크게 향상시킨다.

4.3 구성 요소 분석 (RQ2)

LRD 기반 모델의 각 구성 요소가 추천 성능에 미치는 영향 분석 :

w/o LLM : LLM을 제외하면 성능이 크게 떨어진다. 이는 LLM의 풍부한 언어 지식이 잠재적 관계를 발견하는 데 중요한 역할을 함을 의미한다.
w/o KGE : 지식 그래프 임베딩 작업을 제외하면 성능이 감소하며, 이는 사전 정의된 관계를 모델링하는 것이 중요함을 시사한다.

4.4 잠재적 관계 분석 (RQ3)

LRD가 발견한 잠재적 아이템 관계의 신뢰성을 평가하기 위한 추가 실험 :

관계 임베딩 : 잠재적 관계와 사전 정의된 관계 간에 명확한 차이가 있다. LRD는 관계 추출 모델을 통해 사전 정의된 관계와 잠재적 관계를 구별할 수 있다.
잠재적 관계 아이템 : 모델은 복잡한 다단계 관계를 학습하여 사전 정의된 관계를 넘어서는 더 정교한 사용자 선호를 포착한다.
사례 연구 : KDA 모델은 사전 정의된 관계만을 기반으로 추천하나, LRD 기반 모델은 잠재적 관계를 발견하여 더 나은 성능을 보인다.

4.5 하이퍼파라미터 민감도 분석

LRD의 두 중요한 하이퍼파라미터에 대해 민감도 분석 수행 :

num_latent : 잠재적 관계의 수에 따라 성능이 달라지며, 각 데이터셋에 대해 최적의 값이 다르다.
λ : 잠재적 관계 발견 작업의 계수는 일정 값까지 성능 향상을 보이고, 이후 최적 값을 찾을 수 있다.

6. Conclusion

본 논문에서는 LLM을 기반으로 잠재 아이템 관계를 발견하는 새로운 방법인 LRD(Latent Relation Discovery)를 제안한다. LRD는 자기 지도 학습 접근 방식을 활용하여 LLM의 풍부한 지식을 통해 잠재 아이템 관계를 효과적으로 추출한다. 이 방법은 기존의 관계 인식 순차 추천 시스템과 함께 공동 최적화되어, 다음과 같은 두 가지 주요 기여를 한다.

잠재 관계의 제공 : LRD가 발견한 잠재 관계는 더 정교한 아이템 연관을 제공하며, 이를 통해 복잡한 사용자 선호를 충분히 모델링할 수 있다.
사용자 상호작용 신호의 활용 : 사용자 상호작용에서 얻은 감독 신호는 관계 발견 과정을 효과적으로 안내하며, 잠재 관계의 정확도를 높인다.

여러 공개 데이터셋에 대한 실험 결과, LRD는 기존의 관계 인식 순차 추천 방법들의 성능을 크게 향상시킨다. 추가 분석을 통해 LRD가 발견한 잠재 관계가 신뢰할 수 있음을 확인할 수 있었다. 그러나 현재 구현에서는 LLM이 세밀하게 선택되지 않았다는 점에서, 향후 작업으로 더 발전된 LLM을 사용하는 것이 성능 향상에 중요한 영향을 미칠 가능성이 높다.

[논문] LLaRA: Large Language-Recommendation Assistant

Fri, 21 Mar 2025 05:37:37 GMT

📄 Paper

Representation Learning with Large Language Models for Recommendation [arxiv]

Jiayi Liao ACM SIGIR 24

📝 Key Point

Abstract

목적 : 사용자 과거 상호작용 시퀀스를 기반으로 다음 상호작용을 예측하는 순차 추천 시스템을 개발한다.

배경 : 최근 대형 언어 모델(LLMs)의 발전으로 순차 추천에서 언어 모델링을 활용하려는 관심이 높아지고 있다. 기존 연구들은 아이템을 LLM의 입력 프롬프트에 ID 인덱스나 텍스트 메타데이터로 표현하였으나, 이들 접근법은 포괄적인 세계 지식이나 충분한 행동 이해를 결여하고 있다.

제안 : LLaRA(대형 언어 추천 어시스턴트)를 소개하여 전통적인 추천 시스템의 행동 패턴 캡처 능력과 LLM의 세계 지식 인코딩 능력을 결합한다. 이 시스템은 전통적인 추천 모델로 학습된 ID 기반 아이템 임베딩과 텍스트 아이템 특징을 통합하는 새로운 하이브리드 프롬프트 방법을 사용한다. 사용자 행동을 텍스트와는 별개의 모달리티로 취급하고, 전통 추천 모델의 ID 임베딩을 LLM의 입력 공간에 맞추기 위해 프로젝터를 활용한다.

훈련 전략 : 하이브리드 프롬프트를 LLM에 직접 노출하기보다는 커리큘럼 학습 전략을 채택하여 점진적으로 훈련 복잡성을 증가시킨다. 초기에는 텍스트 전용 프롬프트로 LLM을 워밍업하여 언어 모델링 능력에 적합하게 만든 후, 점진적으로 하이브리드 프롬프트로 전환하여 전통적인 순차 추천 모델의 행동 지식을 LLM에 원활하게 통합하도록 훈련한다.

결과 : 실험 결과는 제안한 프레임워크의 효과성을 입증한다.

Figure

LLaRA 프레임워크

(a) 순차 추천 데이터는 instruction-tuning 형식으로 변환된다. 아이템 표현 예시는 순수 텍스트 토큰에서 행동 토큰과의 통합으로의 전환을 보여준다. (b) 순차 추천 모델은 잘 훈련되어 고정되며, 훈련 가능한 프로젝터가 순차 추천 모델과 LLM 공간을 연결한다.

1. Introduction

목적 : 순차 추천은 사용자의 역사적 상호작용을 기반으로 다음 관심 아이템을 예측하는 것이다. 전통적인 순차 추천 모델은 아이템에 고유 ID를 부여하고 이를 학습 가능한 임베딩으로 변환한 후, 이 임베딩을 통해 사용자 선호도를 포착한다.

LLM의 활용 : 최근 LLM의 성공에 영감을 받아 LLM을 순차 추천에 활용하려는 관심이 증가하고 있다. LLM을 통해 행동 시퀀스를 텍스트 입력 프롬프트로 변환하는 방법이 제안되며, 이는 사용자 행동 패턴을 반영하여 추천의 정확성을 높일 수 있다.

아이템 표현 방법 :

ID 기반 표현은 아이템을 ID 번호로 나타내지만, 텍스트적 특성을 활용하지 못해 LLM의 지식을 저조하게 활용한다.
텍스트 기반 표현은 아이템의 메타데이터(e.g. 제목)를 통해 표현되지만, 사용자 행동 패턴을 충분히 반영하지 못한다.

제안 방법 : 단순한 ID 또는 텍스트 표현 대신, LLM이 사용자 행동 패턴을 깊이 이해할 수 있도록 정렬하는 방법을 탐구한다. 이를 위해 LLaRA(Large Language-Recommendation Assistant)라는 새로운 프레임워크를 제안한다.

LLaRA 프레임워크 :

하이브리드 프롬프트 설계 : 텍스트 전용 및 하이브리드 프롬프트를 통해 아이템의 다면적 표현을 만든다. 하이브리드 프롬프트는 추천 모델에서의 행동 패턴을 통합하여 사용자 행동을 보다 포괄적으로 묘사한다.
커리큘럼 프롬프트 튜닝 : 초기에는 텍스트 전용 프롬프트로 LLM을 워밍업한 후, 하이브리드 프롬프트로 전환하여 추천 모델에서의 행동 지식을 효과적으로 주입한다. 이 전략은 LLM의 순차 추천 능력을 향상시킨다.

실험 결과 : 세 가지 데이터셋(MovieLens, Steam, LastFM)에서 LLaRA의 성능을 평가한 결과, HitRatio@1 지표에서 기존 순차 추천 모델과 LLM 기반 방법들을 일관되게 초월하였다. 또한, 하이브리드 프롬프트와 커리큘럼 프롬프트 튜닝의 중요성을 입증하는 아블레이션 연구도 수행하였다.

결론 : LLaRA는 LLM에 순차 추천 모델을 통합하여 글로벌 지식과 행동 패턴을 아이템 표현에 통합하는 하이브리드 프롬프트 방법과 모달리티 정렬을 위한 커리큘럼 프롬프트 튜닝을 도입하여 효과성을 입증한다.

3. Preliminary

작업 정의 : 사용자에게 시간 순서대로 상호작용한 아이템 시퀀스 $[i_1, i_2, \ldots, i_n]$이 주어질 때, 순차 추천 모델은 사용자가 다음에 상호작용할 아이템 $i_{n+1}$을 예측하는 것이다.

커리큘럼 학습 : 커리큘럼 학습은 모델을 단순한 작업에서 복잡한 작업으로 점진적으로 훈련하는 방법이다. 일반적으로 세 가지 주요 단계로 구성된다:

복잡성 평가 : 각 데이터 포인트 또는 작업의 복잡성을 정량화하여 학습 우선순위를 할당한다.
스케줄러 구성 : 복잡성을 기반으로 모델에 제시할 작업의 순서와 빈도를 배열하는 훈련 스케줄러를 개발한다. 일반적으로 쉬운 작업부터 시작하여 점진적으로 어려운 작업으로 진행한다.
훈련 실행 : 미리 정해진 진행에 따라 커리큘럼 학습 과정을 구현한다.

Instruction 튜닝 : Instruction 튜닝은 LLM이 인간의 작업 특정 instruction을 따르도록하여 성능을 크게 향상시킬 수 있는 중요한 접근법이다. 데이터는 $Z = {(x_i, y_i)}_{i=1}^{N}$ 형태로 재조직되어, $x_i$는 텍스트 instruction, $y_i$는 해당 응답을 나타낸다. 이 쌍 형식은 작업 설명을 포함할 뿐만 아니라 훈련 데이터를 자연어 형식으로 변환하여 포괄적인 instruction적 맥락을 만든다.

Parameter-Efficient Fine-Tuning : LLM의 모든 파라미터를 fine-tuning하는 것은 시간과 자원이 많이 소모된다. 이를 완화하기 위해 Parameter-Efficient Fine-Tuning(PEFT)은 더 작은 파라미터 집합을 최적화하여 계산 요구 사항을 크게 줄이면서도 우수한 성능을 달성한다. LoRA는 전형적인 PEFT 알고리즘으로, LLM 가중치를 고정하고 업데이트할 가중치를 학습 가능한 저차원 행렬로 분해한다.

4. Large Language-Recommendation Assistant (LLARA)

개요 : LLaRA는 전통적인 추천 모델에서 학습한 행동 패턴을 LLM에 통합하기 위한 end-to-end 프레임워크이다. 텍스트 전용 프롬프트를 넘어서 하이브리드 프롬프트를 활용하여 추천 시스템에서 파생된 행동 표현을 LLM의 언어 공간과 정렬한다. 커리큘럼 학습을 적용하여 처음에는 텍스트 전용 프롬프트에 집중한 후 점진적으로 하이브리드 프롬프트로 전환한다. 이 전략은 LLM이 추천 메커니즘을 익히고 전통적인 추천 모델의 행동 지식을 내재화하도록 돕는다.

4.1 Item Representation

텍스트 토큰 표현 : 아이템의 제목과 설명과 같은 텍스트적 특징은 LLM의 지식을 활용하는 데 핵심이다. 아이템 $i$의 텍스트 메타데이터 $txt_i$는 다음과 같이 텍스트 토큰으로 변환된다. $$ = LLM\text-TKZ(txt_i) $$ 여기서 $LLM\text-TKZ(\cdot)$는 LLM의 토크나이저와 단어 임베딩 레이어를 나타낸다.

행동 토큰 표현 : 전통적인 순차 추천 모델(e.g. GRU4Rec, Caser, SASRec)은 역사적 상호작용 데이터에 기반하여 ID 기반 아이템 임베딩 내에서 순차적 패턴을 효과적으로 포착한다. 아이템 $i$의 ID 기반 표현은 다음과 같이 표현된다. $$ e^i_s = SR\text-EMB(i; Θ_e) $$
여기서 $SR\text-EMB(\cdot)$는 추천 모델에 의해 생성된 아이템 임베딩 함수이다. ID 기반 표현은 텍스트 데이터와는 별개의 모달리티로 간주되며, 이를 LLM의 언어 공간과 정렬하기 위해 특별한 모듈인 SR2LLM을 도입한다. ID 기반 표현 $e^i_s$를 LLM 공간으로 $Proj(\cdot)$로 (i.e., two-layer perceptions) 투영하여 행동 토큰 표현 $$를 생성한다. $$ = Proj(e^i_s; Θ_p) $$

하이브리드 토큰 표현 : 텍스트 토큰 $$와 행동 토큰 $$를 통합하여 아이템 $i$의 포괄적인 설명을 생성한다.
$$ = Concat(, ) $$

4.2 Hybrid Prompt Design

텍스트 전용 프롬프트 : 순차 상호작용 데이터를 LLM의 instruction 튜닝에 적합한 훈련 데이터로 변환하기 위해 텍스트 전용 프롬프트 방법을 사용한다. 입력 프롬프트 $x$는 다음과 같은 요소를 포함한다.

작업 정의 : 순차 추천 작업의 명확한 설명
상호작용 시퀀스 : 역사적 사용자-아이템 상호작용 시퀀스
후보 세트 : LLM이 응답을 생성할 후보 아이템 세트

하이브리드 프롬프트 : 추천 모델에서 포착한 행동 인사이트를 프롬프트에 통합하기 위해 하이브리드 프롬프트 방법을 개발한다. 하이브리드 입력 프롬프트 $x$는 다음 세 가지 주요 구성 요소로 변환된다.

작업 정의 : 텍스트 전용 프롬프트와 동일
하이브리드 아이템 표현을 포함한 상호작용 시퀀스 : 역사적 사용자-아이템 상호작용 시퀀스를 하이브리드 아이템 표현으로 나타냄
하이브리드 아이템 표현을 포함한 후보 세트 : 텍스트 및 행동 토큰의 통합으로 표현된 후보 아이템 세트

하이브리드 프롬프트는 텍스트 메타데이터와 ID 기반 아이템 임베딩을 통합하여, ID 기반 또는 텍스트 데이터만 의존하는 프롬프트의 한계를 해결하고 더 정확한 추천을 생성한다.

(a) 텍스트 전용 프롬프트 : 아이템을 텍스트 토큰과 PH(PlaceHolder) 토큰의 조합으로 표현한다.
(b) 하이브리드 프롬프트 : 아이템을 텍스트 토큰과 행동 토큰의 통합으로 표현한다. 여기서 < PH >는 행동 토큰 < $emb^i_s$ >로 대체하기 위해 예약된 PlaceHolder 토큰을 나타낸다.

4.3 Curriculum Prompt Tuning

4.3 커리큘럼 프롬프트 튜닝

개요 : LLM의 설계에 따르면, 주로 텍스트 데이터로 훈련되므로 추천 모델에서 추출한 행동 토큰을 이해하는 작업은 상당한 도전 과제가 된다. 텍스트 전용 프롬프트는 LLM의 훈련과 잘 맞아 쉽게 습득될 수 있지만, 하이브리드 프롬프트는 일반적인 언어 데이터에서 벗어나 더 복잡한 작업을 도입한다.

커리큘럼 학습에서 영감을 받아 LLaRA에서는 커리큘럼 프롬프트 튜닝 방식을 설계한다. 이 튜닝 과정은 더 간단한 프롬프트 방법인 텍스트 전용 프롬프트에 초점을 맞추며 시작된다. 초기 단계에서 모델은 순차 추천 작업에 대한 기본적인 이해를 형성한다. 이후, 행동 토큰을 포함하는 하이브리드 프롬프트 방법을 점진적으로 도입하여 튜닝 과정의 복잡성을 높인다. 이러한 단계적 전략은 모델이 복잡한 작업에 압도되지 않도록 보장한다.

학습 과정의 단계 : 이 학습 과정은 커리큘럼 학습의 세 가지 주요 단계와 일치하며, 다음과 같이 설명할 수 있다:

복잡성 평가 : 커리큘럼 학습의 초기 단계는 각 작업의 복잡성을 평가하는 것이다. LLaRA에서는 하이브리드 프롬프트 설계에서 행동 토큰의 통합과 관련된 작업 복잡성을 정의한다. 여기서 쉬운 작업은 텍스트 전용 프롬프트로 재구성된 순차 데이터로 이루어지고, 어려운 작업은 하이브리드 프롬프트로 재구성된 데이터를 사용한다.
- 쉬운 작업 손실 함수: $$L_{\text{easy}}(x^e, y^e) = -\sum_{t=1}^{|y^e|} \log P_{\Phi_0 + \Delta \Phi(\Theta)}(y^e_t | x^e, y^e_{
- 어려운 작업 손실 함수: $$L_{\text{hard}}(x^h, y^h) = -\sum_{t=1}^{|y^h|} \log P_{\Phi_0 + \Delta \Phi(\Theta) + \Theta_p + \Theta_e}(y^h_t | x^h, y^h_{

이러한 접근 방식은 LLaRA가 행동 토큰을 통합한 하이브리드 아이템 표현으로 완전히 통합될 수 있도록 하는 데 기여한다.

4.3.1 스케줄러 구성

학습 목표 설정 : 쉬운 작업과 어려운 작업의 학습 목표를 설정한 후(식 (7) 및 (8)), 커리큘럼 스케줄러를 구성하여 훈련 과정에서 쉬운 작업에서 어려운 작업으로 점진적으로 전환한다.

학습 확률 정의 : $\tau$ 시점에서 어려운 작업을 학습할 확률을 $p(\tau)$로 정의하며, $1 - p(\tau)$는 쉬운 작업의 확률이다. 초기에는 $p$가 작고, 학습 과정이 진행됨에 따라 점차 증가하도록 설정한다. 이를 연속적으로 표현하면 다음과 같다:
$$p(\tau) = \frac{\tau}{T} \quad (0 \leq \tau \leq T)$$
여기서 $T$는 총 훈련 시간을 의미한다.

4.3.2 훈련 실행

효율성과 효과성의 균형 : LLaRA에 대해 LoRA 튜닝(식 (2) 참조)을 수행하는 동시에 프로젝터도 함께 훈련한다.

지표 함수 정의 :
$$I(\tau) = \begin{cases} 1, & \text{hard task 학습 (확률 } p(\tau) \text{)} \ 0, & \text{easy task 학습 (확률 } 1 - p(\tau) \text{)} \end{cases}$$
학습 목표의 진화 : LLaRA의 학습 목표는 쉬운 작업에서 어려운 작업으로 전환된다:
$$\min_{\Theta, \Theta_p} \sum_{(x, y) \in Z} \left((1 - I(\tau)) L_{\text{easy}}(x, y) + I(\tau) L_{\text{hard}}(x, y)\right)$$

이러한 점진적인 학습 과정은 추가 모달리티를 주입하여 하이브리드 프롬프트 방법을 실현하는 데 기여한다. 커리큘럼 프롬프트 튜닝 전략을 채택함으로써 모델이 텍스트 메타데이터를 이해하는 초기 단계에서 전통적인 추천 모델의 더 복잡한 ID 기반 아이템 임베딩을 이해하는 단계로 원활하게 전환할 수 있도록 한다. 이 전략은 LLM이 추천 메커니즘을 익히고, 순차 추천기에 내재된 행동 지식으로 LLM을 향상시키는 데 기여한다.

[논문] Representation Learning with Large Language Models for Recommendation

Wed, 19 Mar 2025 09:16:54 GMT

📄 Paper

Representation Learning with Large Language Models for Recommendation [arxiv]

Xubin Ren WWW 24

📝 Key Point

RLMRec 프레임워크 : RLMRec은 LLM을 활용하여 추천 시스템의 표현 성능을 향상시키는 모델 비종속적인 프레임워크이다.
대조적/생성적 정렬 기술 : CF 측 관계 임베딩과 LLM 측 semantic 표현을 정렬하여 노이즈를 줄이고 추천 성능을 향상시킨다.
협력 프로파일 생성 : RLMRec은 협력 프로파일 생성 패러다임을 도입하여, 사용자와 아이템 간의 관계를 효과적으로 모델링한다.
추론 기반 시스템 프롬프트 : RLMRec은 생성된 출력에서 추론 과정을 포함함으로써, 추천의 품질을 높이고 사용자 요구에 더 잘 부합하는 정보를 제공한다.

Abstract

배경 및 문제점

추천 시스템은 딥러닝과 그래프 신경망의 발전으로 사용자-아이템 관계를 효과적으로 포착하는 데 큰 발전을 이루었다.
그러나 그래프 기반 추천 시스템은 ID 기반 데이터에 의존하여 텍스트 정보를 간과한다.
또한, implicit feedback 데이터의 사용이 노이즈와 편향을 초래한다.

기존 연구의 한계

LLM을 전통적인 ID 기반 추천 시스템에 통합하는 연구가 주목받고 있다.
그러나 확장성 문제, 텍스트 의존성의 한계, 프롬프트 입력 제약 등의 문제를 해결해야 한다.

제안된 접근법

RLMRec이라는 모델에 구애받지 않는 프레임워크를 제안한다.
RLMRec은 LLM을 활용한 표현 학습을 통해 기존 추천 시스템을 개선하는 것을 목표로 한다.

방법론

보조 텍스트 신호를 통합한다.
LLM을 통한 사용자/아이템 프로파일링을 수행한다.
협업 관계 신호와 LLM의 semantic 공간을 cross-view alignment를 통해 통합한다.
텍스트 신호 통합에 대한 이론적 기초를 상호 정보 극대화를 통해 증명하며, 표현의 질을 향상시킨다.

평가 방법

RLMRec를 SOTA 추천 모델과 통합하여 노이즈 데이터에 대한 효율성과 강건성을 분석한다.

Figure

1. Introduction

배경

추천 시스템은 사용자 상호작용을 기반으로 개인화된 아이템 추천을 제공하기 위해 발전한다.
딥러닝과 그래프 신경망이 중요한 역할을 하며, NGCF와 LightGCN과 같은 그래프 기반 추천 시스템은 복잡한 사용자-아이템 관계를 효과적으로 포착한다.

문제점

최근 그래프 기반 추천 시스템은 학습을 위해 ID에 해당하는 정보에 크게 의존한다.
훈련 데이터는 사용자/아이템 인덱스와 이진 상호작용으로만 구성되며, 이는 텍스트 정보와 같은 중요한 데이터를 간과할 수 있다.
많은 데이터가 implicit feedback으로 구성되어 있으며, 이는 false negative나 편향(e.g. misclick, popularity bias)으로 노이즈를 유발할 수 있다.

False Negative

False Negative는 실제로 사용자가 선호할 가능성이 있는 아이템이 추천되지 않는 경우를 의미한다. 즉, 사용자가 좋아할 만한 아이템이 추천 목록에서 누락되는 상황이다.
Popularity Bias
Popularity Bias는 추천 시스템이 인기 있는 아이템을 선호하여 추천하는 경향을 의미한다. 즉, 사용자에게 추천되는 아이템이 대중적으로 인기가 있는 것들로 편향되는 현상이다.

기존 연구의 한계

LLM의 출현이 추천 시스템의 가능성을 확장할 수 있지만, 기존 방법은 효율성과 정확성에서 부족하다.
주요 문제는 다음과 같다:
1. 실용적인 추천 시스템에서의 확장성 문제 : LLM을 활용한 개인화된 사용자 행동 모델링은 많은 컴퓨팅 자원을 필요로 한다.
2. 텍스트 의존성 : LLM은 환각 문제로 인해 존재하지 않는 아이템에 대한 추천을 생성할 수 있다.

LLM의 한계 검증

Amazon 데이터셋에서 LLM을 사용하여 추천의 re-rank 작업을 평가한다.
LightGCN을 백본 모델로 사용하고, 각 아이템의 텍스트 정보를 사용자 정의 프롬프트와 통합하여 ChatGPT로 처리한다.
LightGCN으로 선별한 40개의 아이템을 LLM으로 re-rank 한다.
추천 재정렬의 목표는 각 사용자에 대해 Top-10, 20 아이템을 식별하는 것이다.
ChatGPT에 의해 세분화된 추천이 LightGCN이 제공한 원래 결과보다 성능이 떨어짐을 확인하였다.
제공된 목록 내에서 존재하지 않는 아이템(초록색 밑줄)을 추천했다.
올바르게 추천된 아이템(빨간색)이 LLM의 결과보다 LightGCN의 결과에 더 많다.
이러한 한계는 LLM의 환각 문제, 토큰 제한, 높은 계산 비용에 기인한다.

제안 방법

LLM의 힘을 활용하여 기존 추천 시스템을 향상시키기 위한 RLMRec이라는 모델 비종속 프레임워크를 제안한다.
RLMRec은 ID 기반 추천 시스템과 LLM 간의 연결 고리로 표현 학습을 활용하며, 사용자 행동과 선호를 이해하는 것을 목표로 한다.
보조 텍스트 신호를 표현 학습에 통합하는 이점을 모델링하여 이론적 기초를 마련한다.
LLM의 semantic 공간과 협업 관계 신호의 표현 공간을 cross-view alignment 프레임워크를 통해 정렬하여 추천 성능을 향상시킨다.

기여

LLM을 활용하고 협업 관계 모델링과의 semantic 공간을 정렬하여 기존 추천 시스템의 추천 성능을 향상시킬 가능성을 탐색하는 것을 목표로 한다.
이론적 발견에 기반한 RLMRec이라는 모델 비종속 표현 학습 프레임워크를 제안한다. 이 프레임워크는 대조적 또는 생성적 모델링 기술을 활용하여 학습된 표현의 질을 향상시킨다.
텍스트 신호를 통합하여 표현 학습을 향상시키는 효과의 이론적 기초를 확립한다. 상호 정보 극대화를 활용하여 텍스트 신호가 표현 품질을 개선할 수 있는 방법을 보여준다.
RLMRec을 다양한 SOTA 추천 모델과 통합하고, 방법의 효과성을 검증하며, 프레임워크의 노이즈 및 불완전 데이터에 대한 강건성을 분석하여 실제 문제를 처리할 수 있는 능력을 보여준다.

3. Methodology

3.1 Theoretical Basis of RLMRec

3.1.1 Collaborative Filtering

추천 시나리오에서 사용자 집합 $U$와 아이템 집합 $V$를 설정한다.
관찰된 사용자-아이템 상호작용은 $X$로 표현되며, 각 사용자와 아이템은 초기 임베딩 $x_u$와 $x_v$를 할당받는다.
목표는 추천 모델을 통해 사용자와 아이템 표현 $e_u$, $e_v$를 학습하는 것이며(즉, $e_u, e_v = R(x_u, x_v)$), 이 모델은 아래의 사후 확률 분포를 최대화한다. $$ p(e|X) \propto p(X|e)p(e) $$
실제 상호작용 $X$는 노이즈(false positive, false negative)를 포함할 수 있으며, 이는 추천 정확도에 부정적인 영향을 미친다.
false positive : 잘못 클릭하거나 인기 편향의 영향을 받은 상호작용 false negative : 사용자가 보지 못했지만 관심있는 아이템
이 연구에서는 추천에 유익한 히든 사전 지식(prior belief) $z$를 도입하여 진정한 긍정 샘플을 식별하도록 한다. $z$는 $e$와 $s$를 연결해 주는 latent space이다.

사후 확률 (Posterior Probability)

사후 확률 : 주어진 데이터나 증거를 기반으로 특정 사건의 확률
가능도(Likelihood) : 특정 사건이 주어졌을 때 관측된 데이터를 기반으로 하는 확률
$p(e|X) \propto p(X|e)p(e)$
이 수식은 베이즈 정리를 기반으로 한 사후 확률 분포를 설명한다.
$p(e|X)$ : 주어진 상호작용 데이터 $X$에 대한 사용자와 아이템의 표현 $e$의 사후 확률이다. 즉, 사용자가 특정 아이템과 상호작용한 데이터를 바탕으로 해당 사용자와 아이템의 표현이 얼마나 가능성이 높은지를 나타낸다.
$p(X|e)$ : 주어진 표현 $e$에 대한 사용자-아이템 상호작용 데이터 $X$의 가능도이다. 이는 특정 표현이 주어졌을 때, 이 표현이 실제로 관찰된 상호작용 데이터 $X$를 생성할 확률을 의미한다.
$p(e)$ : 표현 $e$의 사전 확률이다. 이는 모델이 학습하기 전에 표현이 어떤 분포를 가질 것인지에 대한 사전 정보이다. 즉, 특정 표현이 얼마나 일반적인지를 나타낸다.
이 관계는 "사후 확률은 가능도와 사전 확률의 곱에 비례한다"는 의미이다. 즉, 관찰된 데이터 $X$를 기반으로 하여 표현 $e$의 가능성을 업데이트한다. 이 과정은 모델이 주어진 데이터에 맞게 사용자 및 아이템의 표현을 튜닝하도록 한다. 사후 확률 $p(X|e)$를 최대화하는 것은 모델이 데이터에 잘 적합하고 최적의 표현 $e$를 찾는 과정이다.

3.1.2 Text-enhanced User Preference Learning

관련 없는 신호의 영향을 완화하기 위해 보조 정보 신호를 통합하는 것이 필요하다.
사용자 및 아이템 프로필을 텍스트 정보로 도입하여 사용자 선호를 효과적으로 포착하는 표현 $s$를 생성한다.
협업 표현 $e$와 텍스트 표현 $s$는 추천에 유익한 정보를 포함하고, 조건부 확률을 최대화하여 최적의 $e$ 값을 학습하는 것이 목표이다: $$ e^* = \arg \max_e E_{p(e,s)}[p(z, s|e)]. $$
조건부 확률을 최대화함으로써 추천 모델로부터 학습된 표현이 사전 지식 $z$에서 생성된 순수한 정보와 semantic 표현 $s$와의 공유 정보를 포함하도록 보장한다.

Theorem 1

히든 사전 지식 $z$가 주어진 상태에서, 사후 확률 $E_{p(e,s)}[p(z, s|e)]$를 최대화하는 것은 CF 측 관계 표현 $e$와 LLM 측 semantic 표현 $s$ 간의 상호 정보 $I(e, s)$를 최대화하는 것과 동등하다.
"$z$라는 latent 변수를 통해 최적화하는 것은 결국 $e$와 $s$ 간의 정보량을 최대화하는 것과 같다."는 점을 수학적으로 보여주기 위한 것이다.

Proof

사용자와 아이템의 프로필이 고정되어 있어 학습 과정 동안 확률 $p(s)$는 일정하다. $$ E_{p(e,s)}[p(z, s|e)] \propto E_{p(e,s)} \log\left[\int_z\frac{p(z, s|e)}{p(s)}dz\right] $$
$E_{p(e,s)}[p(z, s|e)]$ : 주어진 $e$에 대해 $z$와 $s$의 결합 확률.
$E_{p(e,s)} \log\left[\int_z \frac{p(z, s|e)}{p(s)}dz\right]$ : $p(z, s|e)$를 $p(s)$로 나누어 정규화. 이때 $p(s)$는 고정된 값이므로, 이 식은 $z$에 대한 조건부 확률을 강조한다.
비례 관계는 두 식이 동일한 정보량을 나타내지만, 한 쪽이 다른 쪽의 상수 배에 해당함을 의미한다. 즉, 이 두 식은 같은 정보를 가지고 있다.
$\frac{p(z,s|e)}{p(s)}=\frac{p(z,s,e)}{p(s)p(e)}=\frac{p(z,e|s)}{p(e)}$ $$ = E_{p(e,s)} \log\left[\int_z \frac{p(z,e|s)}{p(e)}dz\right] $$
$z$에 대해 적분해서 $z$의 영향력을 제거한다. 이 과정에서 $z$를 적분하는 것은 $z$의 모든 가능한 값에 대해 평균을 구하는 것이다. $z$의 모든 가능한 값에 대해 $p(z,e|s)$를 누적하여 $s$와 $e$의 관계를 명확히 한다. $$ = E_{p(e,s)} \log\left[\frac{p(e|s)}{p(e)}\right] $$
정보 이론 $I(X; Y) = E_{p(X,Y)}[\log\left(\frac{p(X|Y)}{p(X)}\right)]$ $$ = I(e, s) $$

Theorem 2

상호 정보를 보존하기 위해 밀도 비율(density ratio)을 도입함으로써 $f(s, e) \propto \frac{p(s|e)}{p(s)}$를 사용하여, $I(e_i; s_i)$의 최대화는 다음과 같은 하한을 최대화하는 것으로 재구성될 수 있다: $$ E \log\left[\frac{f(s_i, e_i)}{\Sigma_{s_j \in S} f(s_j, e_i)}\right] $$
- 밀도 비율(density ratio) : 두 확률 분포의 비율 $\frac{p(s|e)}{p(s)}$
- $\frac{p(s|e)}{p(s)}$ : $e$라는 조건이 주어졌을 때 $s$가 얼마나 더 잘 나타나는지를 보여주는 지표
- $\frac{p(s|e)}{p(s)}$는 상호 정보의 핵심 구성 요소 ( $I(s_i; e_i) = E_{p(s_i,e_i)}[\log\left(\frac{p(s_i|e_i)}{p(s_i)}\right)]$ )
- 모델 점수 함수 $f(s,e)$를 상호 정보를 나타내는 $\frac{p(s|e)}{p(s)}$로 설정
softmax 형태의 목적함수를 정당화하는 이론적 증명이다.

Proof

상호 정보의 성질을 바탕으로, $I(e_i, s_i) = I(s_i, e_i)$이다. $$ I(s_i, e_i) \geq I(s_i, e_i) - \log(N) $$
$I(s_i; e_i) = E_{p(s_i,e_i)}[\log\left(\frac{p(s_i|e_i)}{p(s_i)}\right)]$ $$ = -E \log\left[\frac{p(s_i)}{p(s_i|e_i)}N\right] $$
$\frac{p(s_i)}{p(s_i|e_i)}N \leq \frac{p(s_i)}{p(s_i|e_i)}N + (1 -\frac{p(s_i)}{p(s_i|e_i)})$
$\frac{p(s_i)}{p(s_i|e_i)} \leq 1$ , $p(s_i|e_i) \geq p(s_i)$
조건부 확률 $p(s_i|e_i)$는 이미 $e_i$가 주어진 상황에서 $s_i$가 발생할 확률이라서 일반 확률 $p(s_i)$보다 높아지는 것이 자연스럽다. 조건부 확률은 추가적인 정보를 주기 때문에 그 사건에 대한 불확실성을 줄여준다. $e_i$는 $s_i$에 대한 유익한 정보를 담고 있기 때문에 조건부 확률이 더 높다. $$ \geq -E \log\left[1 + \frac{p(s_i)}{p(s_i|e_i)}(N - 1)\right] $$
negative sample의 영향력을 고려하여 기대값을 추가한다. $S_{neg}$는 $i$번째 샘플을 고려할 때의 부정 샘플을 나타낸다. ($S_{neg} = S \setminus s_i$) $$ = -E \log\left[1 + \frac{p(s_i)}{p(s_i|e_i)}(N - 1) E_{s_j \in S_{neg}} \frac{p(s_j|e_i)}{p(s_j)}\right] $$
큰 샘플 수에서 합이 기대값과 비슷하므로 기대값을 합으로 근사한다. positive sample을 제외한 $(N-1)$이 negative sample의 개수이다. $$ \approx -E \log\left[1 + \frac{p(s_i)}{p(s_i|e_i)} \sum_{s_j \in S_{neg}} \frac{p(s_j|e_i)}{p(s_j)}\right] $$
$f(s, e) \propto \frac{p(s|e)}{p(s)}$를 이용하여 softmax 형태로 나타낸다. 분자는 정답 후보의 score를 나타내고, 분모는 모든 후보의 score 합을 나타낸다. $$ = E \log\left[\frac{f(s_i, e_i)}{\Sigma_{s_j \in S} f(s_j, e_i)}\right] $$

Challenges

이 접근법은 두 가지 도전 과제를 제시한다.
1. 사용자와 아이템의 상호작용 선호를 포착하는 효과적인 설명을 얻는 방법.
2. $e$와 $s$ 간의 상호 정보를 최대화하기 위해 밀도 비율 $f(s, e)$를 효과적으로 모델링하는 방법.

3.2 User/Item Profiling Paradigm

프로파일의 필요성

사용자와 아이템에 대한 텍스트 설명(프로파일)의 중요성을 강조한다.
역할 : 노이즈 영향을 완화하고 사용자와 아이템 간의 상호작용 선호를 의미적으로 이해할 수 있도록 한다.

이상적인 프로파일 특성

사용자 프로파일 : 사용자가 선호하는 아이템 유형을 효과적으로 요약하고 개인의 취향을 포괄적으로 표현해야 한다.
아이템 프로파일 : 아이템이 끌어당길 가능성이 있는 사용자 유형을 명확히 설명하고, 해당 사용자들의 선호와 관심사에 맞는 특성을 제공해야 한다.

원본 데이터의 문제점

누락된 속성 : 특정 아이템이나 사용자의 일부 속성이 누락될 수 있음.
노이즈가 많은 텍스트 : 텍스트에 사용자 선호와 무관한 노이즈가 포함될 수 있음.

LLM을 활용한 제안 방법

LLM의 발전으로 텍스트 노이즈 제거 및 요약이 가능해졌다.
협력적 정보를 기반으로 한 프로파일 생성 패러다임을 제안한다.
아이템 속성에 대한 텍스트 설명 비율이 사용자 속성보다 높다는 점을 고려하여 item-to-user 관점을 취한다.

3.2.1 추론을 통한 프로파일 생성 (Profile Generation via Reasoning)

최근 연구에서는 LLM에 과정 추론을 통합하여 출력 품질을 향상시키는 효과를 입증했다.
시스템 프롬프트 설계 : 입력과 출력의 내용과 원하는 출력 형식을 명확하게 지정하여 사용자와 아이템의 프로파일을 생성하는 기능을 분명히 정의한다. $$ P_u = LLMs(S_u, Q_u), \quad P_v = LLMs(S_v, Q_v) $$
$P$ : 프로파일, $S$ : 시스템 프롬프트, $Q$ : 프로파일 생성 프롬프트

3.2.2 아이템 프롬프트 구성 (Item Prompt Construction)

프롬프트 구성: $$ Q_v = f_v(x) \cdot w.r.t., \quad x = \begin{cases} [\alpha, \beta], & \text{if } \beta \text{ exists}, \ [\alpha, \gamma, \hat{r} \subset r], & \text{otherwise.} \end{cases} $$
$\alpha$ : 제목, $\beta$ : 원본 설명, $\gamma=\gamma_1, ..., \gamma_{|\gamma|}$ : 데이터셋 특정 속성, $r = r_1, ..., r_n$ : 사용자 리뷰 집합
각 아이템에 특정한 함수 $f_v(\cdot)$를 사용하여 다양한 텍스트 특성을 하나의 문자열로 결합한다.
원본 설명 $\beta$가 누락된 경우, 리뷰의 하위 집합 $\hat{r}$을 무작위로 샘플링하고 이를 속성 $\gamma$과 결합하여 입력으로 사용한다.

사용자가 선호할 만한 책의 유형을 요약하도록 지시하여 추천 목적으로 유용한 정보를 제공한다. 언어 모델의 출력은 JSON 형식을 준수해야 한다.
Input Prompt : 입력 정보는 데이터셋의 책 제목과 원본 설명으로 구성된다.
Generated Item Profile : 생성된 프로파일에 대한 언어 모델의 추론을 제공하는 것이 중요하며, 이는 고품질 요약을 보장하고 잠재적인 환각을 방지한다.
예시 : 책 설명에서 독자가 정신 건강 및 여성의 경험에 관심이 있을 가능성이 있음을 언어 모델이 정확하게 포착하였다.

3.2.3 사용자 프롬프트 구성 (User Prompt Construction)

이미 생성된 아이템 프로파일을 기반으로 사용자 프로파일을 생성한다.
프롬프트 구성: $$ Q_u = f_u({c_v | v \in \hat{I}_u }). $$
$c_v$ : 텍스트 속성, $I_u$ : 사용자 $u$가 상호작용한 아이템 집합, $r^v_u$ : 사용자 $u$가 제공한 리뷰
사용자 $u$가 상호작용한 아이템들이 $I_u$일 때, 그 중에서 아이템의 하위 집합 $\hat{I}_u \subset I_u$를 균등하게 샘플링한다.
$\hat{I}_u$의 각 아이템 $v$에 대해, 텍스트 속성을 $c_v = [\alpha, P_v, r^v_u]$로 연결한다.
함수 $f_u(\cdot)$는 텍스트 내용을 일관된 문자열로 구성하는 역할을 한다.
각 텍스트 속성 $c_v$에는 사용자의 리뷰가 포함되어 있어 그들의 진정한 의견을 진솔하게 반영한다.

item-to-user 생성 패러다임을 채택하여, 아이템의 상호작용 선호를 설명하는 이전에 생성된 프로파일을 활용할 수 있게 한다.
이를 위해 아이템에 대한 사용자 피드백 정보뿐만 아니라 아이템 자체의 프로파일도 포함한다.
두 정보 출처를 종합적으로 활용함으로써, LLM은 사용자 선호를 더 높은 정확도로 포착할 수 있다.
예시 : 책 설명과 사용자 리뷰 텍스트를 활용하여 언어 모델이 초자연적 요소를 결합한 청소년 소설에 대한 사용자의 선호를 도출한다.

3.3 Density Ratio Modeling for Mutual Information Maximization

상호 정보 최대화를 위한 밀도 비율 모델링

밀도 비율 $f(s_i, e_i)$를 모델링하여 상호 정보 $I(s_i, e_i)$를 최대화하는 과정을 설명한다.

semantic 표현 인코딩

프로파일 생성 : 사용자/아이템 프로파일 $P_{u/v}$를 기반으로 semantic 표현 $s$를 인코딩한다. $$ s_u = T(P_u), \quad s_v = T(P_v) $$
$T(\cdot)$ : 텍스트 임베딩 모델로, 텍스트를 고정 길이 벡터로 변환한다.

밀도 비율 해석

정의 : 밀도 비율 $f(s_i, e_i)$는 $s_i$와 $e_i$의 유사성을 포착하는 양의 실수 값 점수 측정 함수이다.
효과 : 밀도 비율의 정확한 모델링은 CF측 표현과 LLM-enhanced 표현 간의 정렬을 개선하고 표현 학습에서 노이즈 영향을 완화시킨다.

모델링 접근 방식 제안

대조적 모델링 : 서로 다른 view를 양방향으로 효과적으로 정렬하는 방법이다.
생성적 모델링 : 부분적으로 마스킹된 입력을 재구성하며 학습한다. CF측 표현을 사용하여 semantic 표현을 재구성함으로써 두 형태의 정보를 효과적으로 정렬할 수 있다.

3.3.1 Contrastive Alignment

$$ f(s_i, e_i) = \exp(sim(\sigma_{\downarrow}(s_i), e_i)) $$

$exp(\cdot)$ : 유사성을 확률적으로 표현, $sim(\cdot)$ : 코사인 유사성, $\sigma_{\downarrow}$ : semantic 표현 $s_i$를 $e_i$의 피처 공간으로 매핑하는 다층 퍼셉트론
긍정 샘플 쌍 $e_i$와 $s_i$를 서로 끌어당겨 표현을 정렬한다.
구체적인 구현에서는 긍정 샘플 쌍을 batch 내에서 서로 가깝게 만드는 것을 목표로 하며, 나머지 샘플은 negative로 간주된다.

3.3.2 Generative Alignment

MAE(masked autoencoder)에 대한 연구에서 영감을 받아, MAE 내에서 밀도 비율을 위한 추가 모델링 접근 방식을 제안한다. $$ f(s_i, e_i) = \exp(sim(s_i, \sigma_{\uparrow}(\hat{e}_u))) \quad \text{where } \hat{e}_i = R({x} \setminus x_i) $$
$\sigma_{\uparrow}$ : 표현을 semantic 피처 공간으로 매핑하는 다층 퍼셉트론 모델, $x \setminus x_i$ : 마스킹이 적용된 $i$번째 샘플의 초기 임베딩
생성 과정은 단일 방향 재구성 접근 방식을 따르며, 마스킹된 샘플에 대해 semantic 표현을 재구성하는 데 집중한다.
구체적으로, 마스킹 작업은 초기 임베딩을 지정된 마스크 토큰(i.e. [MASK])으로 교체하고, 무작위로 선택된 사용자/아이템을 마스킹한 후 재구성한다. 이를 통해 semantic 피처 공간 내에서 재구성 능력을 탐색할 수 있다.

정렬 효과

대조적 정렬와 생성적 정렬 방법을 통해 LLM의 지식을 사용자 선호 이해 영역과 효과적으로 정렬한다.
이는 ID 기반 협력 관계 신호와 텍스트 기반 행동 의미를 결합함으로써 달성된다.

모델 이름

RLMRec-Con
RLMRec-Gen

3.4 Model-agnostic Learning

모델 비종속적 접근

지금까지 CF측 관계 표현 $e$와 LLM측 semantic 표현 $s$의 최적화에 집중해왔다.
사용자와 아이템에 대한 표현 학습을 수행할 수 있는 모든 모델은 앞서 설명한 최적화 과정을 거칠 수 있다.

최적화 함수 $$ L = L_R + L_{\text{info}} \quad w.r.t \quad L_{\text{info}} = -E \log\left[\frac{f(s_i, e_i)}{\Sigma_{s_j \in S} f(s_j, e_i)}\right] $$

$L_R$ : 추천 시스템 $R$의 최적화 목표
최적화 함수 $L$을 최소화하는 것은 앞서 언급한 상호 정보를 최대화하는 것과 일치한다.

4. Evaluation

Research Question

RQ1 : RLMRec이 다양한 실험 환경에서 기존의 SOTA 추천 시스템을 개선하는가?
RQ2 : LLM-enhanced semantic 표현이 추천 성능 향상에 기여하는가?
RQ3 : RLMRec이 cross-view semantic alignment을 통해 노이즈 데이터 문제를 효과적으로 해결하는가?
RQ4 : 추천 시스템 성능 향상을 위한 사전 훈련 프레임워크로서의 모델의 잠재력은 무엇인가?
RQ5 : RLMRec의 훈련 효율성은 어떤가?

4.1 Experimental Settings

4.1.1 Datasets

Amazon-book : Amazon에서 판매되는 책에 대한 사용자 평가 및 리뷰
Yelp : 다양한 사업체에 대한 광범위한 텍스트 카테고리 정보를 제공하는 사용자-사업체 데이터셋
Steam : Steam 플랫폼에서 제공되는 게임에 대한 사용자 피드백

Amazon-book과 Yelp 데이터에서는 평가 점수가 3 미만인 상호작용을 필터링한다. Steam 데이터셋은 평가 점수가 없어 필터링을 적용하지 않는다.
이후 k-core 필터링을 수행하고 각 데이터셋을 3:1:1 비율로 훈련, 검증, 테스트 세트로 나눈다.

k-core filtering

k-core는 그래프에서 각 노드의 차수가 최소 k 이상인 서브그래프를 의미한다.
k-core에 포함된 모든 노드가 최소한 k개의 이웃 노드를 가지도록 노드와 엣지를 필터링한다.
그래프의 밀집한 구조를 강조하고, 노드 간의 강한 연결을 보존하는 데 유용하다.
추천 시스템이나 소셜 네트워크 분석 등에서 데이터의 품질을 높이고, 노이즈를 줄이는 데 기여할 수 있다.
필터링 과정*
- 초기 그래프에서 차수가 k 미만인 노드를 제거한다.
- 노드를 제거할 때마다 그 노드와 연결된 엣지도 함께 제거되므로, 이로 인해 다른 노드의 차수도 변경될 수 있다.
- 이러한 과정을 반복하여 더 이상 차수가 k 미만인 노드가 없을 때까지 진행한다.

4.1.2 Evaluation Protocols and Metrics

포괄적인 평가와 편향 완화를 위해 모든 항목에 대해 all-rank 프로토콜을 채택한다.
Recall@N과 NDCG@N을 사용하여 모델의 성능을 측정한다.

4.1.3 Base Models

GCCF : GNN에서 비선형 연산의 역할을 재평가하여 그래프 기반 추천 설계를 단순화한 모델
LightGCN : 그래프 메시지 전달에서 중복 뉴럴 모듈을 간소화하여 경량화한 추천 모델
SGL : 대조 학습을 위한 다양한 관점 생성하기 위해 노드/엣지 드롭아웃을 사용하여 데이터를 증강한 모델
SimGCL : 증강 없는 view 생성 기법을 도입하여 추천 성능을 향상시킨 모델
DCCF : 분리된 대조 학습(disentangled contrastive learning)을 사용하여 추천을 위한 의도 기반 관계를 캡처하는 모델
AutoCF : 추천을 위한 데이터 증강 프로세스를 자동화하는 self-supervised masked autoencoder 모델

4.1.4 Implementation Details

사용자/아이템 프로파일 생성 : ChatGPT (gpt-3.5-turbo)
semantic 표현 $s$ 생성 : text-embedding-ada002 (OpenAI)
dimension of representations (i.e. $x$, $e$) : 32
batch : 4096, learning rate : 1e-3, optimizer : Adam
hyperparameters : grid search
early stopping : validation set 성능 기반

4.2 Performance Comparison (RQ1)

모델 비종속적 성능 향상

목적 : RLMRec을 여섯 가지 SOTA 협업 필터링 모델에 통합하여 성능을 향상시키는 것을 입증한다.
방법 : 5회의 무작위 초기화를 사용하여 평균 결과를 확인한다.
성능 향상 : 전반적으로, RLMRec을 백본 추천 시스템과 통합하면 원래 버전보다 성능이 향상되는 것이 일관되게 관찰된다.
- 요인 1 : RLMRec은 LLM에 의해 강화된 정확한 사용자/아이템 프로파일링을 가능하게 하여 사용자 상호작용 행동에서 풍부한 semantic 정보를 향상시킨다.
- 요인 2 : cross-view 상호 정보 최대화는 CF측 관계 임베딩과 LLM측 semantic 표현의 협력적 향상을 촉진하여 추천 기능에서 관련 없는 노이즈를 효과적으로 필터링한다.
대조적/생성적 모델링 : 대조적/생성적 모델링 접근 방식은 일반적으로 성능을 향상시킨다.
- 그러나 대조적 접근 방식은 GCCF 및 SimGCL과 같은 다양한 백본과 결합할 때 우수한 성능을 보인다.
- 반면, mask 재구성을 포함하는 AutoCF에 적용할 경우, RLMRec-Gen은 더 큰 향상을 보인다. mask 작업이 정규화 형태로 작용하여 생성적 접근 방식을 사용하는 방법과 함께 사용할 때 더 나은 결과를 낳는다고 추측한다.

LLM-enhanced 접근 방식에 대한 우수성

목적 : RLMRec의 효과를 최근 LLM-enhanced 사용자 행동 모델링 접근 방식인 KAR와 비교 평가한다.
KAR와 비교 :
- KAR는 CTR 작업을 위한 사용자 선호 학습을 강화하기 위해 텍스트 사용자/아이템 설명을 생성하는 것을 목표로 한다.
- KAR는 텍스트 지식을 사용자 행동 표현과 효과적으로 정렬하지 못할 수 있으며, 사용자 행동이나 LLM 지식 기반에서 발생하는 관련 없는 노이즈에 더 취약할 수 있다.
- RLMRec은 사용자 행동 표현과 텍스트 지식을 효과적으로 정렬한다.

4.3 Ablation Study (RQ2)

목적 : semantic 표현 통합이 성능에 미치는 영향을 조사한다.
방법 : semantic 표현을 무작위로 섞어 CF 측 관계 표현과 LLM의 지식을 불일치시킨다. 기본 인코딩 모델인 text-embedding-ada-002와 추가로 Contriever, Instructor를 사용한다.
결과 :
- 무작위로 섞인 표현이 CF와 semantic 정보 간의 불일치를 초래하여 성능이 감소한다. 이는 LLM의 semantic 지식과 사용자 간의 협력 관계 간의 정확한 정렬이 추천 성능 향상에 중요함을 나타낸다.
- Contriever와 Instructor 모델을 사용할 때도 RLMRec은 기본 성능을 향상시킨다. 이는 RLMRec이 텍스트 semantic 표현을 선호 표현으로 변환할 수 있는 적절한 텍스트 인코더를 효과적으로 활용할 수 있음을 시사한다.

Contriever

Contriever는 정보 검색 및 질문 응답 시스템에서 효과적으로 사용되는 텍스트 임베딩 모델로, 주어진 문서나 텍스트에서 관련 정보를 추출하는 데 초점을 맞춘다.
특징 : contrastive learning 기법을 사용하여, 문서와 쿼리 간의 유사성을 극대화하고, 관련 없는 정보는 최소화하는 방식으로 학습된다. 이는 사용자 쿼리와 관련된 문서를 더 잘 찾는 데 도움을 준다.
Instructor
Instructor는 주로 텍스트 생성 및 요약 작업을 위한 텍스트 임베딩 모델로, 사용자의 요청에 따라 적절한 응답을 생성하는 데 초점을 맞춘다.
특징 : 사용자 피드백이나 특정 지침을 기반으로 학습되며, 더욱 정교하고 사용자 친화적인 텍스트 출력을 생성하는 데 도움을 준다. 이 과정에서 LLM을 활용하여 보다 자연스럽고 일관성 있는 결과를 제공한다.

4.4 In-depth Analysis of RLMRec (RQ3 – RQ5)

4.4.1 Performance w.r.t. Noisy Data (RQ3)

목적 : RLMRec의 데이터 노이즈에 대한 강건성을 평가한다.
방법 : 원래 훈련 데이터에 존재하지 않는 상호작용을 추가하여 노이즈 수준을 5%에서 25%까지 조정한다.
결과 :
- RLMRec-Con과 RLMRec-Gen 모두 모든 노이즈 수준에서 LightGCN 모델보다 우수하다. 이는 의미 정보를 통합하고 상호 정보를 활용하여 관련 없는 데이터를 필터링함으로써 추천을 개선하고 노이즈에 대한 강건성을 높이는 장점을 강조한다.
- RLMRec-Con은 RLMRec-Gen에 비해 데이터 노이즈에 더 잘 견디는 것으로 나타난다. 이는 생성적 방법에 노드 마스킹을 통해 도입되는 고유 노이즈로 인한 것일 수 있다. 반면 대조적 방법은 노이즈가 적게 발생하여 동일한 노이즈 비율에서 우수한 성능을 발휘한다.

4.4.2 Performance in Pre-training Scenarios (RQ4)

목적 : Pre-training 기술로서의 RLMRec의 잠재력을 탐구한다.
방법 : Yelp 데이터셋을 사용하여 2012년부터 2017년까지의 데이터를 사전 훈련에 활용한다.
결과 :
- Pre-training을 수행한 경우가 수행하지 않은 경우보다 우수한 결과를 얻는다. 이는 Pre-training 데이터셋이 사용자/아이템 선호 예측에 도움이 되는 귀중한 협력 정보를 포함하고 있음을 시사한다.
- RLMRec-Con과 RLMRec-Gen 모두 기본 모델만으로 Pre-training하는 것보다 더 나은 사전 성과를 보이며, RLMRec-Gen이 가장 좋은 결과를 달성했다. 이는 Pre-training 시나리오에서 semantic 정보 통합과 생성적 방법의 효과를 강조하며, mask 작업의 규제 기능이 overfitting을 방지하는 데 기여할 수 있음을 나타낸다.

4.4.3 Analysis of Training Efficiency (RQ5)

목적 : RLMRec 사용의 시간 복잡성을 분석한다.
결과 :
- MLP에 대한 시간 복잡성은 RLMRec-Con과 RLMRec-Gen 모두 $O(N × d_s × d_e)$이다.
- RLMRec-Con의 경우, 손실 계산이 추가적인 복잡성 $O(N^2 × d)$를 도입한다. RLMRec-Gen의 경우, 시간 복잡성은 $O(M × d + M × N × d)$이며, 마스킹 작업은 $M × d$를 차지하고, 여기서 $M$은 마스킹된 노드의 수를 나타낸다.
- RLMRec-Gen의 시간 비용이 RLMRec-Con보다 낮으며, 이는 batch 크기와 마스킹된 노드 수의 차이에서 기인한다. 주로 RLMRec-Con의 N 값이 배치 크기로 결정되며, 이는 RLMRec-Gen의 마스킹된 노드 수 M보다 더 큰 경향이 있기 때문이다.

4.5 Case Study

목적 : LLM-enhanced semantics를 활용하여 직접적인 메시지 전달로 포착할 수 없는 사용자 관계를 탐구한다.
결과 : RLMRec을 사용하여 학습된 표현이 ID 기반 추천 기술을 넘어서는 글로벌 협력 관계를 포착한다.

사용자 $u_{1998}$과 $u_{227}$ 간의 거리가 3hop을 초과하여 공통점이 적다.
모델이 이들의 관계를 포착하는 능력을 평가하기 위해 사용자 표현의 유사성을 조사한다.
$u_{1998}$과 $u_{227}$ 간의 공유 관심사 같은 LLM에서 파생된 의미 정보(e.g. 친절한 서비스)를 통합함으로써 관련 점수와 순위가 증가하는 것이 관찰된다.
이는 RLMRec에서 학습된 표현이 기존 추천 시스템으로 알 수 없었던 잠재적인 공통점을 포착한다는 것을 시사한다.

5 Conclusion

RLMRec은 LLM을 활용하여 추천 시스템의 표현 성능을 개선하는 모델 비종속 프레임워크이다.
협력 프로파일 생성 패러다임과 추론 기반 시스템 프롬프트를 도입하며, 생성된 출력에서 추론 과정의 포함을 강조한다.
대조적/생성적 정렬 기술을 활용하여 LLM 측 semantic 표현과 CF 측 관계 임베딩을 정렬하여 노이즈를 줄인다.
향후 연구는 추천 시스템에서 LLM 기반 추론 결과를 개선하여 더 통찰력 있는 설명을 제공하는 데 집중할 예정이다.

[논문] CoLLM: Integrating Collaborative Embeddings into Large Language Models for Recommendation

Fri, 14 Mar 2025 03:59:02 GMT

📄 Paper

CoLLM: Integrating Collaborative Embeddings into Large Language Models for Recommendation [arxiv]

Yang Zhang IEEE TKDE 24

📝 Key Point

협업 정보 모델링의 중요성 : LLMRec의 추천 성능을 향상시키기 위해 협업 정보를 효과적으로 모델링하는 것이 중요하다는 점을 강조한다.
CoLLM의 개발 : CoLLM은 LLMRec을 위해 협업 정보를 통합하는 새로운 접근 방식으로, 전통적인 협업 모델을 LLM에 외부화하여 유연하고 효과적인 모델링을 가능하게 한다.
Warm & Cold 시나리오 : CoLLM은 warm 시나리오와 cold 시나리오 모두에서 LLM의 성능을 성공적으로 향상시키며, 협업 정보의 필요성을 입증한다.

Abstract

배경 : LLM을 추천 시스템에 활용하는 연구가 주목받고 있다. 기존의 LLMRec 접근법은 텍스트 의미에 중점을 둔다. 사용자-아이템 상호작용에서의 협업 정보를 간과하는 경향이 있다.

문제점 : 텍스트 중심의 접근법은 콜드 스타트 상황에서는 우수하다. 그러나 웜 스타트 상황에서는 최적의 성능을 내지 못할 수 있다.

제안 방법 : CoLLM이라는 혁신적인 LLMRec 방법론을 제안한다. CoLLM은 협업 정보를 외부의 전통적인 모델을 통해 캡처한다. 이를 LLM의 입력 토큰 임베딩 공간에 매핑하여 협업 임베딩을 생성한다.

특징 : 협업 정보의 외부 통합을 통해 LLM 자체를 수정하지 않고도 효과적으로 협업 정보를 모델링한다. 다양한 협업 정보 모델링 기법을 적용할 수 있는 유연성을 제공한다.

결과 : 광범위한 실험을 통해 CoLLM이 협업 정보를 LLM에 효과적으로 통합하여 추천 성능을 향상시킴을 입증한다.

Figure

key components

Prompt Construction
Hybrid Encoding
LLM Prediction

1. Introduction

LLM의 발전 : LLM인 GPT-3와 LLaMA는 빠른 발전을 이루었으며, 맥락 이해, 추론, 일반화, 세계 지식 모델링 등에서 뛰어난 성능을 보여준다. 이러한 능력은 다양한 분야에서 LLM을 탐색하고 활용하려는 열정을 불러일으켰다.

LLM 기반 추천 시스템 : 추천 시스템은 웹에서 개인화된 정보 필터링의 핵심 엔진으로, LLM의 발전으로부터 상당한 이익을 얻을 것으로 기대된다. LLM의 세계 지식과 맥락 이해 능력은 콜드 아이템 및 사용자 모델링을 향상시킬 수 있다. 이러한 기대는 LLM을 추천자로 활용하는 새로운 방향(LLMRec)을 제시한다.

기존 연구의 한계 : LLM을 추천자로 활용하기 위해 기존 연구들은 In-Context Learning에 의존하였다. 그러나 많은 연구 결과는 원래의 LLM이 정확한 추천을 제공하는 데 어려움을 겪고 있음을 나타낸다. 이는 특정 추천 작업에 대한 훈련 부족 때문이다. 이러한 문제를 해결하기 위해 LLM을 관련 추천 데이터로 추가적인 fine-tuning을 실시하는 노력이 증가하고 있다. 그럼에도 불구하고 이러한 방법들은 잘 훈련된 전통적인 추천 모델을 초월하지 못할 수 있으며, 특히 웜 사용자/아이템에 대한 성능이 저조할 수 있다.

In-Context Learning

In-Context Learning은 LLM이 특정 작업을 수행하기 위해 사전 훈련된 지식을 활용하는 방법이다. 이 접근법은 모델이 새로운 작업이나 질문에 대한 응답을 제공하기 위해 추가적인 훈련 없이 주어진 입력 맥락(context)만으로 학습하듯이 행동하는 것을 의미한다.

협업 정보의 중요성 : 기존 LLMRec 방법의 주요 한계는 사용자-아이템 상호작용에서의 협업 정보를 충분히 모델링하지 못한다는 점이다. 이 방법들은 사용자와 아이템을 텍스트 토큰으로 표현하며, 주로 텍스트 의미에 의존하여 협업 정보를 포착하는 데 한계가 있다. 협업 정보는 추천 성능에 유익하지만, 이러한 정보를 무시하면 성능 저하가 발생할 수 있다.

연구 문제 제안 : 따라서, 우리는 협업 정보를 LLM에 효율적으로 통합하여 콜드 및 웜 사용자/아이템 모두에 대해 성능을 최적화할 수 있는 방법을 제시하는 새로운 연구 문제를 제안한다.

문제 해결 접근법 : 협업 정보를 LLM에서 명시적으로 모델링하는 방법을 제안한다. 고전적인 협업 필터링 경험을 바탕으로, 사용자와 아이템을 나타내는 추가 토큰과 임베딩을 LLM에 도입하는 것이 간단한 해결책이 될 수 있다. 이는 latent factor 모델(e.g. Matrix Factorization)에서 사용자/아이템 임베딩이 수행하는 역할과 유사하다. 하지만 직접적으로 토큰 임베딩을 추가하면 대규모 추천에서 확장성이 감소하고 토큰화 중복성이 증가하여 정보 압축률이 낮아질 수 있다. 이는 협업 정보가 일반적으로 저랭크(low-rank) 특성을 가지므로 예측 작업을 더욱 어렵게 만들 수 있다.

low-rank

rank : 랭크(rank)는 행렬의 선형 독립적인 행 또는 열의 최대 수를 나타내며, 해당 행렬이 정보를 얼마나 잘 표현하는지를 나타낸다. 랭크가 낮다는 것은 특정 행렬의 랭크가 전체 크기에 비해 상대적으로 낮은 경우를 의미한다.
low-rank의 특징 : Low-rank 행렬은 데이터에서 중요한 패턴이나 구조를 포착하면서도 불필요한 노이즈를 줄일 수 있는 특성을 가진다. 이는 데이터 압축이나 차원 축소에 유용하게 사용된다.
추천 시스템 : 추천 시스템과 같은 분야에서는 사용자-아이템 상호작용 데이터를 low-rank 행렬로 모델링하여 사용자와 아이템 간의 잠재적인 관계를 파악하는 데 활용한다. 예를 들어, 행렬 분해 기법(e.g. Matrix Factorization)은 이러한 low-rank 특성을 이용하여 추천을 개선하는 방법이다.

CoLLM 제안 : 이러한 한계를 극복하기 위해 CoLLM을 제안한다. CoLLM은 협업 정보를 별도의 모달리티로 취급하며, 잘 훈련된 전통적인 협업 모델에서 MLP를 사용해 직접 매핑하여 LLM에 도입한다. CoLLM은 두 단계의 튜닝 과정을 사용한다. 첫째, 추천 작업을 학습하기 위해 언어 정보만을 사용하여 LLM을 fine-tuning한다. 둘째, 매핑 모듈을 튜닝하여 매핑된 협업 정보가 LLM의 추천에서 이해 가능하고 유용하도록 만든다.

장점 : 이 접근법은 기존 LLM과 유사한 확장성을 유지하면서도 다양한 협업 정보 모델링 메커니즘을 구현할 수 있는 유연성을 제공한다. 전통적인 모델의 지식을 LLM과 정렬함으로써 협업 정보를 효과적으로 통합할 수 있다.

주요 기여 :

협업 정보 모델링의 중요성을 강조하여 LLMRec이 웜 및 콜드 사용자/아이템 모두에서 잘 작동하게 한다.
외부 전통 모델의 능력을 활용하여 협업 정보를 LLM에 효과적으로 통합하는 CoLLM을 소개한다.
두 개의 실제 데이터셋에 대한 광범위한 실험을 수행하여 제안의 효과성을 입증한다.

3. Preliminaries

문제 정의

데이터셋 $D$ : 역사적 상호작용 데이터셋을 나타내며, 각 데이터 포인트는 $(u, i, y)$로 구성된다.
- $u$ : 사용자, $i$ : 아이템, $y$ : 상호작용 레이블로, $y \in {1, 0}$로 표시된다.
텍스트 정보 : 아이템에 대한 추가 텍스트 정보가 제공되며, 주로 아이템 제목의 형태로 존재한다.
목표 : 상호작용 데이터와 텍스트 정보를 활용하여 LLM을 추천 용도로 fine-tuning하는 것이다. LLM이 텍스트 정보 외에 협업 정보를 효과적으로 활용할 수 있도록 하여, 웜 및 콜드 추천 시나리오에서 우수한 성능을 달성하는 것이 목표이다.

LLM

처리 과정
1. 토큰화 및 임베딩 조회 : 입력 텍스트를 의미 있는 어휘 토큰으로 변환하고, 이를 벡터 공간에 임베딩한다.
2. 맥락 모델링 및 출력 생성 (LLM 예측) : 주로 디코더 전용 트랜스포머 아키텍처를 기반으로 한 신경망을 사용하여 토큰 임베딩을 처리하고, 일관되고 맥락적으로 관련된 출력을 생성한다.
사용 모델 : 추천을 위해 Vicuna-7B 모델을 사용한다.

전통적인 협업 추천 모델

주요 접근법 : latent factor 모델(e.g. MF, LightGCN)을 통해 협업 정보를 인코딩한다. 이 방법들은 일반적으로 사용자와 아이템을 잠재 요인, 즉 임베딩으로 표현한다.
수식 : 각 샘플 $(u, i, y) \in D$에 대해 다음과 같이 표현된다.
- $$u = f_\psi(u; D)$$
- $$i = f_\psi(i; D)$$
- 여기서 $u \in \mathbb{R}^{1 \times d_1}$는 사용자의 표현을 나타내며, $d_1$은 차원이다. $f_\psi(u; D)$는 이 표현을 얻기 위한 과정을 나타내고, $\psi$는 모델 매개변수를 의미한다.
예측 과정 : 사용자 및 아이템 표현은 상호작용 모듈에 입력되어 예측을 생성하며, 실제 상호작용 레이블에 대한 예측 오류를 최소화함으로써 상호작용 데이터 내의 협업 정보를 인코딩하도록 학습한다.

4. Methodology

접근 방식

기존 모델 활용 : LLM을 직접 수정하는 대신, 전통적인 모델을 사용하여 협업 정보를 추출하고, 이 결과를 LLM이 이해하고 활용할 수 있는 형식으로 변환한다.
협업 정보 통합 : 최근 multi-modal LLM의 발전에 영감을 받아 협업 정보를 통합하는 방법을 제안한다. 이는 CoLLM 방법론의 기초가 된다.

4.1 Model Architecture

구성 요소

Prompt Construction : 추천 데이터를 언어 프롬프트로 변환하는 단계.
Hybrid Encoding : 생성된 프롬프트를 인코딩하고 LLM에 입력하여 추천을 생성하는 단계.
LLM Prediction : 최종적으로 추천을 생성하는 단계.

혁신적인 접근

프롬프트 구성 : 텍스트 설명 외에 사용자 및 아이템 ID 필드를 추가하여 협업 정보를 나타낸다.
프롬프트 인코딩 : LLM의 토큰화 및 텍스트 정보 인코딩 외에, 전통적인 협업 모델을 사용하여 사용자/아이템 표현을 생성하고 이를 LLM의 토큰 임베딩 공간으로 매핑한다.
텍스트 정보와 협업 정보를 토큰 임베딩 공간 내에서 함께 표현한 후, LLM은 두 가지 유형의 정보를 활용하여 추천을 수행할 수 있다.

4.1.1 Prompt Construction

고정 프롬프트 템플릿 : 프롬프트 생성을 위해 고정된 템플릿을 활용한다. 이는 TALLRec과 유사한 접근 방식이다.
아이템 설명 : 아이템은 제목을 사용하여 설명한다.
사용자 설명 : 사용자는 과거 상호작용에서의 아이템 제목을 통해 설명된다.
협업 정보 통합 : 협업 정보를 통합하기 위해 의미를 가지지 않은 사용자 및 아이템 ID 관련 필드를 도입한다. 이 필드는 프롬프트 내에서 협업 정보를 위한 자리 표시자 역할을 한다.

user and item ID-related fields
- ⟨HisItemTitleList⟩ : 사용자가 상호작용한 아이템 제목의 목록으로, 상호작용 타임스탬프에 따라 정렬되어 사용자의 선호를 설명한다.
- ⟨TargetItemTitle⟩ : 예측할 대상 아이템의 제목을 나타낸다.
- ⟨UserID⟩, ⟨TargetItemID⟩ : 각각 사용자 및 아이템 ID를 나타내며, 협업 정보를 주입하는 데 사용된다.
의미적 일관성 유지 : 사용자 및 아이템 ID를 통합하면서 의미적 일관성을 유지하기 위해, 이들을 프롬프트 내에서 사용자/아이템의 특성(feature)으로 간주한다.
샘플 기반 프롬프트 구성 : 각 추천 샘플에 대해, 네 개의 필드를 샘플의 해당 값으로 채워 샘플 특정 프롬프트를 구성한다.

4.1.2 Hybrid Encoding

목적 : 입력 프롬프트를 LLM 처리를 위한 잠재 벡터(임베딩)로 변환하는 데 사용된다. 텍스트 및 협업 정보를 효과적으로 통합하여 LLM이 추천을 수행할 수 있도록 한다.
접근 방식 : 하이브리드 인코딩 방식을 채택한다.
텍스트 콘텐츠 처리 : 모든 텍스트 콘텐츠에 대해 LLM의 내장된 토큰화 및 임베딩 메커니즘을 활용하여 텍스트를 토큰으로 변환하고, 이후 토큰 임베딩으로 변환한다.
사용자 및 아이템 ID 처리 : "⟨UserID⟩" 및 "⟨TargetItemID⟩" 필드에 대해서는 전통적인 협업 추천 모델로 구성된 CIE(Collaborative Information Encoding) 모듈을 사용하여 협업 정보를 추출한다.
프롬프트 토큰화 : 샘플 $(u, i, y) \in D$에 해당하는 프롬프트를 LLM 토크나이저를 사용하여 토큰화한다. 토큰화 결과는 다음과 같이 표현된다. $$ P = [t_1, t_2, \ldots, t_k, u, t_{k+1}, \ldots, i, \ldots, t_K], $$ 여기서 $t_k$는 텍스트 토큰을 의미하며, $u/i$는 "⟨UserID⟩"/"⟨TargetItemID⟩" 필드에 배치된 사용자/아이템 ID를 나타낸다.
임베딩 시퀀스 : 프롬프트를 임베딩 시퀀스로 인코딩한다. $$ E = [e_{t_1}, \ldots, e_{t_k}, e_u, e_{t_{k+1}}, \ldots, e_i, \ldots, e_{t_K}], $$
- $e_{t_k} \in \mathbb{R}^{1 \times d_2}$: LLM에서 $t_k$에 대한 토큰 임베딩.
- $e_u/e_i \in \mathbb{R}^{1 \times d_2}$: 사용자 $u$ 및 아이템 $i$에 대한 협업 정보 임베딩.
CIE 모듈
- 구성 요소 : CIE 모듈은 전통적인 협업 모델($f_\psi(\cdot)$)과 매핑 레이어($g_\phi(\cdot)$)로 구성된다.
- 기능 : 사용자 $u$와 아이템 $i$를 제공받아 협업 정보를 인코딩한 사용자 및 아이템 ID 표현($u$ 및 $i$)을 생성한다. 이후 매핑 레이어는 이러한 표현을 LLM의 토큰 임베딩 공간으로 매핑하여 최종 잠재 협업 임베딩($e_u$ 및 $e_i$)을 생성한다.
- 협업 정보 추출 과정 : 협업 정보 추출 과정은 다음과 같이 표현된다. $$ e_u = g_\phi(u), \quad u = f_\psi(u; D), $$ $$ e_i = g_\phi(i), \quad i = f_\psi(i; D), $$ 여기서 $u = f_\psi(u; D) \in \mathbb{R}^{1 \times d_1}$는 사용자 표현을 나타내며, $d_1$은 차원이다.
- 협업 모델 구현 : CIE 모듈은 전통적인 협업 추천 모델로 구현될 수 있다.
- 매핑 레이어 구현 : 매핑 레이어는 MLP로 구현되며, 입력 크기는 사용자/아이템의 차원 $d_1$과 같고, 출력 크기는 LLM 임베딩 크기 $d_2$와 같다. (보통 $d_1 < d_2$)

4.1.3 LLM Prediction

입력 프롬프트 임베딩 : 입력된 프롬프트가 임베딩 시퀀스 $E$로 변환된 후, LLM은 이를 사용하여 예측을 생성할 수 있다.
LLM의 한계 : LLM은 특정 추천 작업에 대한 훈련이 부족하기 때문에, LLM에만 의존하지 않고 추가적인 모듈을 도입한다.
LoRA 모듈 도입 : 추천 예측을 수행하기 위해 LoRA(Low-Rank Adaptation) 모듈을 추가한다. 이 모듈은 LLM의 원래 가중치에 랭크 분해 가중치 행렬(rank-decomposition weight matrices) 쌍을 추가하는 방식으로 구현된다.
목적: 새로운 작업(추천)을 학습하기 위해 몇 개의 매개변수만을 도입하면서도 효과적으로 학습할 수 있도록 한다.
예측 수식 : 예측은 다음과 같이 수식화된다. $$ \hat{y} = h_{\hat{\Theta} + \Theta'} (E) $$
- 여기서 $\hat{y}$는 레이블이 1일 확률, 즉 LLM이 "Yes"라고 대답할 가능성을 나타낸다.
- $\hat{\Theta}$는 사전 훈련된 LLM의 고정 모델 매개변수를 나타내고, $\Theta'$는 추천 작업을 위한 학습 가능한 LoRA 매개변수를 의미한다.
Plug-in 접근법 : LoRA를 사용함으로써, 추천 작업을 학습하기 위해 LoRA 가중치만 업데이트하면 되므로 파라미터 효율적인 학습이 가능하다.

LoRA (Low-Rank Adaptation)

LoRA는 LLM과 같은 복잡한 모델을 효율적으로 튜닝하기 위한 기법이다.

저랭크 튜닝 : LoRA는 모델의 기존 가중치에 저랭크의 행렬을 추가하여 새로운 작업(e.g. 추천, 특정 응용 분야 등)을 학습할 수 있도록 한다. 이렇게 하면 전체 모델을 수정하지 않고도 특정 작업에 맞게 튜닝할 수 있다.
파라미터 효율성 : LoRA는 기존의 대형 모델에 비해 상대적으로 적은 수의 추가 매개변수를 사용하여 학습할 수 있다. 이는 훈련 시간과 자원 소비를 줄이는 데 기여한다.
플러그인 방식 : LoRA는 기존 모델에 플러그인 형태로 추가되어, 기존의 모델 구조를 유지하면서도 새로운 기능을 학습할 수 있게 한다.
적용 범위 : LoRA는 다양한 자연어 처리 작업에 적용될 수 있으며, 특히 한정된 데이터로도 효과적으로 학습할 수 있는 장점이 있다.

4.2 Tuning Method

매개변수 훈련 : 모델 매개변수를 훈련하기 위해 LLM(임베딩 레이어 포함)을 고정하고, plug-in LoRA 모듈과 CIE 모듈의 튜닝에 집중한다.
- CIE 모듈 : 협업 정보를 추출하고 LLM이 추천에 사용할 수 있도록 변환하는 역할.
- LoRA 모듈 : LLM이 추천 작업을 학습하도록 지원.
문제점과 제안 방법 : 협업 정보에 대한 의존성이 크기 때문에 두 모듈을 동시에 훈련하면 콜드 시나리오에서 LLM 추천 성능이 저하될 수 있다. 두 단계 튜닝 접근법을 통해 각 구성 요소를 개별적으로 튜닝한다.

Step 1 : LoRA 모듈 튜닝

목적 : LLM의 콜드 스타트 추천 기능을 부여하기 위해 LoRA 모듈을 독립적으로 튜닝한다.
프로세스 : 협업 정보 관련 부분을 제외하고 텍스트 전용 세그먼트만 사용하여 예측을 생성하고 예측 오류를 최소화한다.
수식 표현 : $$ \hat{\Theta}' = \arg\min_{\Theta'} \sum_{(u,i,y) \in D} \ell(h_{\hat{\Theta} + \Theta'} (E_t), y) $$
- 여기서 $E_t$는 텍스트 전용 프롬프트에 대한 임베딩 시퀀스, $\ell$은 이진 교차 엔트로피(BCE) 손실을 나타낸다.

Step 2 : CIE 모듈 튜닝

목적 : CIE 모듈이 협업 정보를 효과적으로 추출하고 매핑하도록 학습한다.
프로세스 : 협업 정보가 포함된 프롬프트를 사용하여 예측을 생성하고 CIE 모델을 튜닝하여 예측 오류를 최소화한다.
수식 표현 : $$ \min_{\Omega} \sum_{(u,i,y) \in D} \ell(h_{\hat{\Theta} + \Theta'} (E), y) $$
- 여기서 $E$는 전체 프롬프트에 대한 임베딩 시퀀스, $\Omega$는 CIE 모듈의 모델 매개변수이다.
매개변수 튜닝 방식
1. $\Omega = \phi$ : 매핑 레이어 $g_\phi$만 튜닝하며, 잘 훈련된 협업 모델 $f_\psi = \hat{\psi}$를 사용.
  - 매핑 함수 튜닝에만 집중하므로 더 빠를 수 있다.
2. $\Omega = {\phi, \psi}$ : 협업 모델 $f_\psi$와 매핑 레이어 $g_\phi$를 모두 튜닝.
  - 협업 정보를 LLM에 더 매끄럽게 통합할 수 있어 성능 향상 가능성이 있다.

위 두 단계는 한 번만 수행된다.
Step 2에서는 LoRA를 튜닝하지 않고 CIE 모듈만 튜닝한다. 첫 번째 단계 후 LLM은 이미 추천 작업을 수행할 수 있는 능력을 갖추고 있으며, 협업 정보는 매핑된 상태에서 LLM이 추천을 수행할 수 있도록 활용되기 때문이다.

4.3 Discussion

Relation to Soft Prompt Tuning

비교 : LoRA 모듈 없이 우리의 방법은 추천 시스템에서 소프트 프롬프트 튜닝의 변형으로 볼 수 있으며, 협업 임베딩이 소프트 프롬프트 역할을 한다.
차별점 :
1. low-rank 특성 : LLM이 사용하는 소프트 프롬프트는 전통적인 협업 모델의 low-rank 표현에서 파생되어 low-rank 특성을 유지한다.
2. 추가적인 지침 제공 : 협업 모델이 소프트 프롬프트 학습에 대한 가치 있는 제약 조건과 사전 조건을 제공하여 협업 정보를 보다 효과적으로 캡처하고 개인화된 정보를 인코딩하는 데 추가적인 지침을 제공한다.

Hard Prompt

고정된 텍스트 : 하드 프롬프트는 특정 태스크를 수행하기 위해 사용자가 명시적으로 작성한 고정된 텍스트이다.
수동 설정 : 하드 프롬프트는 사용자가 직접 설정해야 하며, 태스크에 따라 다양한 형식으로 작성할 수 있다.
일반화의 한계 : 하드 프롬프트는 특정 태스크에 맞게 작성되기 때문에 다른 태스크로의 일반화가 어려울 수 있다.
Soft Prompt
학습 가능한 벡터 : 소프트 프롬프트는 고정된 텍스트 대신 학습 가능한 파라미터로 구성된 벡터이다. 이 벡터는 모델이 특정 태스크에 대해 최적화된 방식으로 반응하도록 유도한다.
자동 튜닝 : 소프트 프롬프트는 데이터에 기반하여 모델이 자동으로 튜닝될 수 있습니다. 이는 사용자가 수동으로 프롬프트를 설계할 필요 없이, 모델이 학습 과정에서 최적의 프롬프트를 찾아내는 것을 의미한다.
전이 학습 가능 : 소프트 프롬프트는 다양한 태스크에서 사용할 수 있으며, 특정 작업에 대한 성능을 개선하는 데 더 유연하다. 이는 모델의 일반화 능력을 향상시키는 데 기여한다.
비교
하드 프롬프트는 고정된 텍스트로 수동 설정되며, 특정 태스크에 맞춰 작성되어 일반화에 한계가 습니다.
소프트 프롬프트는 학습 가능한 벡터로 자동 조정되며, 다양한 태스크에 대해 유연하고 일반화 능력이 뛰어나다.

Inference Efficiency

문제 인식 : LLMRec, 특히 CoLLM의 상대적으로 높은 계산 비용은 실제 응용에 장애가 될 수 있다.
가속화 기술 : LLM을 위한 다양한 가속화 기술이 등장하고 있으며, 캐싱 및 재사용과 같은 방법들이 유망한 결과를 보여준다. CoLLM도 이러한 기술을 활용하여 추론 효율성을 향상시킬 수 있다.
미래 연구 방향 : 협업 정보를 통합하여 추천 품질을 향상시키는 것이 목표인 만큼, 가속화 방법의 탐색은 향후 연구에 위임된다.
CoLLM의 경량성 : 기존 LLMRec 방법들(e.g. TALLRec)와 비교할 때, CoLLM은 CIE 모듈만 도입한다. CIE 모듈은 LLM에 비해 훨씬 작으며, LLM의 업데이트 없이 훈련이 이루어진다. 따라서 CoLLM은 훈련 및 추론 과정에서 과도한 추가 오버헤드를 발생시키지 않는다.

5. Experiments

RQ1 : Can our proposed CoLLM effectively augment LLMs with collaborative information to improve recommendation, in comparison to existing methods?

CoLLM이 협업 정보를 통해 LLM의 추천 성능을 개선할 수 있는가?

RQ2 : What impact do our design choices have on the performance/efficiency of the proposed method? How does the method perform on other datasets and LLM backbones?

설계 선택이 제안된 방법의 성능 및 효율성에 미치는 영향은 무엇인가?

5.1 Experimental Settings

데이터셋

ML-1M : 영화 추천 데이터셋으로, 2000-2003년 동안 수집된 사용자 영화 평가로 구성된다. 평점 3 이상을 "긍정"(y = 1)으로, 나머지는 "부정"(y = 0)으로 변환한다. 최근 20개월의 상호작용을 기준으로 훈련(10개월), 검증(5개월), 테스트(5개월) 세트로 분할한다.
Amazon-Book : 아마존의 도서 추천 데이터셋으로, 1996-2018년 사이의 사용자 리뷰를 포함한다. 리뷰 점수 4 이상을 "긍정"으로 변환한다. 2017년의 상호작용을 기준으로 훈련(11개월)과 검증 및 테스트(각각 2개월) 세트로 분할한다.

5.1.1 Evaluation Metrics

AUC : ROC 곡선 아래 면적으로, 전체 예측 정확도를 정량화한다.
UAUC : User-based Area Under the Curve, 각 사용자에 대해 AUC를 계산한 후 평균하여 사용자 단위의 순위 품질을 제공한다.

5.1.2 Compared Methods

전통적인 협업 방법 : MF, LightGCN
언어 모델과 협업 모델 결합 방법 : SASRec, DIN, CTRL(DIN)
LLMRec 방법 : ICL, Prompt4NR, TALLRec
MF : Matrix Factorization, 잠재 요인 기반 협업 필터링 방법 중 하나이다.
LightGCN : 사용자 관심 모델링을 향상시키기 위해 간소화된 그래프 컨볼루션 신경망을 활용하는 대표적인 그래프 기반 협업 필터링 방법이다.
SASRec : 사용자 관심을 모델링하기 위해 순차적 패턴을 인코딩하는 self-attention 네트워크를 사용하는 대표적인 순차 추천 방법이다. 이는 순차 정보를 고려하는 협업 방법으로 볼 수 있다.
DIN : 특정 아이템에 대한 사용자 관심을 학습하기 위해 가장 관련성 높은 사용자 행동을 활성화하는 attention 메커니즘을 사용하는 대표적인 협업 클릭률(CTR) 모델이다.
CTRL(DIN) : 지식 증류를 통해 언어 모델과 협업 모델을 결합하는 SOTA 방법으로, 협업 모델로 DIN을 활용한다.
ICL : In-Context Learning, LLM의 In-Context 학습 능력을 기반으로 하는 LLMRec 방법으로, 프롬프트를 사용하여 원래 LLM에 직접 추천을 요청한다.
Prompt4NR : 고정 프롬프트와 소프트 프롬프트를 모두 사용하여 전통적인 언어 모델(e.g. BERT)을 추천 목적으로 활용하는 SOTA 방법이다. 이 방법을 Vicuna-7B에 확장하여 공정한 비교를 위해 LLM을 LoRA로 튜닝하여 계산 비용을 관리한다.
TALLRec : 지시 튜닝을 통해 LLM과 추천을 정렬하는 최첨단 LLMRec 방법으로, Vicuna-7B에서 구현된다.

5.1.3 ImplementationDetails

프레임워크 : 모든 방법을 PyTorch 2.0으로 구현한다.
손실 함수 : Binary Cross-Entropy (BCE)를 사용한다.
최적화 알고리즘 : 대형 언어 모델에는 AdamW, 기타 모델에는 Adam을 사용한다.
하이퍼파라미터 튜닝 :
- 학습률 : [1e-2, 1e-3, 1e-4] 범위
- 임베딩 크기 : [64, 128, 256] 범위
- 가중치 감소 : LLM 기반 방법에 대해 1e-3, 다른 모델에 대해 [1e-2, 1e-3, ..., 1e-7] 범위로 튜닝한다.
SASRec : 최대 상호작용 시퀀스 길이를 훈련 데이터의 평균 사용자 상호작용 수에 따라 설정한다.
TALLRec : 모든 방법에 대해 최대 시퀀스 길이를 10으로 설정한다.
DIN 및 CTRL(DIN) : 드롭아웃 비율과 숨겨진 레이어 크기를 추가로 튜닝한다.

5.2 Performance Comparison (RQ1)

5.2.1 Overall Performance

CoLLM의 성능 : CoLLM은 두 데이터셋에서 모든 비교 방법 중 최고의 성능을 보이며, 이는 협업 정보를 통합한 접근 방식의 우수성을 입증한다.
LLMRec 방법과의 비교 : LLMRec의 최상의 기준선인 TALLRec은 대체로 MF, LightGCN, SASRec보다 우수하지만 DIN에는 미치지 못한다. 그러나 CoLLM을 통해 LLMRec에 협업 정보를 도입한 결과, LLM의 성능이 일관되게 향상되었다(단, 아마존 북의 SASRec에 대한 UAUC 제외). 이는 협업 정보의 필요성을 강조한다.
LLMRec 방법의 성능 : ICL 방법은 일관되게 가장 낮은 성능을 보이며, 이는 LLM의 추천에 대한 내재적 한계를 보여준다. Prompt4NR는 LLM을 fine-tuning하면서 적응 가능한 프롬프트를 포함하지만, 여전히 CoLLM의 성능에는 미치지 못하며 TALLRec보다도 뒤처진다. 이는 CoLLM의 성능 향상이 협업 정보 모델링에 기인함을 시사한다.
CTRL 접근법 : LM과 협업 모델을 통합하는 CTRL은 한 지표를 향상시키면 다른 지표에는 부정적인 영향을 미친다. 이는 LM의 강점과 협업 정보를 효과적으로 활용하는 데 한계가 있음을 나타낸다. CoLLM은 이러한 한계를 극복하여 성능을 지속적으로 개선한다.
CIE 모듈의 효과 : CoLLM의 CIE 모듈은 다양한 협업 모델과 함께 구현되었을 때, 일관되게 성능 향상을 보여주며, CoLLM의 성능은 해당 협업 모델의 성능과 긍정적인 상관관계를 가진다.

Ensemble

MF와 TALLRec 모델을 앙상블하여 CoLLM-MF 접근 방식과 비교하고, CoLLM-MF와 MF의 추가 앙상블 효과를 조사했다.
MF와 TALLRec의 앙상블은 CoLLM-MF에 비해 성능이 저조했지만, CoLLM-MF에 앙상블 평균을 적용하면 약간의 성능 향상이 있었다.
CoLLM의 협업 정보와 LLM 통합 메커니즘은 단순한 앙상블 기법을 초월하여 LLM의 기능을 효과적으로 활용함을 보여준다. CoLLM-MF 접근 방식이 더 우수한 성능을 나타낸다.

5.2.2 Performance in Warm and Cold Scenarios

Warm 시나리오 : TALLRec는 MF에 비해 낮은 AUC 점수를 보이며, MF는 CoLLM에 비해 낮다. UAUC 측면에서는 MF가 TALLRec에 미치지 못하고, TALLRec는 CoLLM에 뒤처진다. 이는 기존 LLMRec 방법이 Warm 시나리오에서 단점이 있음을 시사하며, 협업 정보를 도입하면 성능이 개선될 수 있음을 보여준다.
Cold 시나리오 : TALLRec와 CoLLM은 모두 MF보다 우수한 성능을 보이며, CoLLM은 TALLRec와 유사한 성능을 유지한다. 이는 CoLLM이 Cold 시나리오에서도 LLMRec의 강점을 효과적으로 활용하고 있음을 나타낸다.

종합적으로, CoLLM은 Warm 시나리오에서 TALLRec에 비해 상당한 성능 개선을 보이며, Cold 시나리오에서도 능력을 유지하고 있다. 이는 협업 정보를 성공적으로 통합하여 LLMRec가 두 시나리오 모두에서 효과적으로 작동하도록 하는 CoLLM의 목표를 강조한다.

5.3 In-depth Analysis (RQ2)

5.3.1 The Effect of CIE Module

CIE 모듈의 중요성 : CoLLM의 성능에 대한 CIE 모듈의 영향을 평가하기 위해, CoLLM-MF와 두 가지 변형을 비교한다.
1. "w/o CIE" : CIE 모듈을 생략한 변형 (TALLRec와 동일).
2. "w/ UI-token" : CIE 모듈을 생략하고 사용자와 아이템을 직접 나타내는 토큰 및 임베딩을 사용하는 변형.
비교 결과 : "w/o CIE" 변형은 CoLLM보다 낮은 성능을 보이며, "w/ UI-token" 변형도 CoLLM보다 성능이 낮고, 오히려 CIE 없이 모델링한 경우보다 더 나쁜 성능을 기록한다. 이는 LLM에서 직접 토큰을 도입하는 것이 협업 정보를 효과적으로 포착하지 못함을 시사한다. CIE 모듈은 협업 정보를 저차원 상태로 유지하여 중복성을 줄이고 성능을 향상시킨다.

5.3.2 The Influence of Tuning Choices

튜닝 전략 : CoLLM의 성능에 대한 훈련 선택의 영향을 분석한다. 기본적으로 두 단계 튜닝 전략을 사용하며, 첫 번째 단계에서 LoRA 모듈을 학습하고, 두 번째 단계에서 CIE 모듈의 매핑 레이어를 튜닝한다.
추가 튜닝 전략:
- T1 : 기본 두 단계 튜닝과 동일하나, 전체 CIE 모델을 튜닝.
- T2 : 기본 두 단계 튜닝을 따르지만, CIE 모델을 처음부터 튜닝.
- T3 : 한 단계 튜닝 접근법으로 LoRA 모듈과 CIE의 매핑 레이어를 동시에 튜닝.
비교 결과 : 두 단계 업데이트 프레임워크 내에서 T1과 T2는 성능 향상을 가져오지만, 추가적인 계산 비용과 느린 수렴 속도를 초래한다. T3는 상대적으로 낮은 성능을 보이며, 특히 Cold 시나리오에서 성능 저하가 두드러진다. 이는 첫 번째 단계에서 텍스트 전용 데이터를 사용하여 추천 작업을 학습하는 것이 중요함을 강조한다.

5.3.3 Efficiency

효율성 문제 : LLMRec의 효율성 문제를 조사한다. CIE 모듈의 훈련에서 추가 비용이 발생하지만, 협업 모듈의 사전 훈련 덕분에 CoLLM은 TALLRec에 비해 훈련 시간의 증가가 약 15.5%에 불과하다.
추론 비용 : CIE 모듈의 비용은 LLM에 비해 미미할 것으로 예상되며, 추가 토큰이 필요하지만 전체 프롬프트의 일부에 불과하다. CoLLM은 평균적으로 총 추론 비용이 12.5% 증가한다.

5.3.4 Method Generalization

다른 LLM 백본 : Qwen2-1.5B 백본을 사용하여 CoLLM-MF와 TALLRec의 성능을 비교한 결과, CoLLM이 항상 TALLRec와 MF를 초과하는 성능을 보인다. 이는 다양한 LLM 백본에서의 일반적인 적용 가능성을 보여준다.
다른 데이터셋 : 아마존 데이터셋의 비디오 게임 및 CDs & Vinyl 데이터셋을 포함하여 CoLLM-MF의 성능을 MF 및 TALLRec와 비교한 결과, 협업 정보를 통합함으로써 LLMRec를 효과적으로 향상시킬 수 있음을 나타낸다. 비디오 게임 데이터셋에서 AUC 값은 MF: 0.6161, TALLRec: 0.7356, CoLLM-MF: 0.7440이며, CDs & Vinyl 데이터셋에서는 MF: 0.6957, TALLRec: 0.6607, CoLLM-MF: 0.7237로 나타났다. 이는 다양한 데이터셋에서 제안된 방법의 일관된 우수성을 나타낸다.

6. Conclusion

협업 정보 모델링의 중요성 : 본 연구에서는 LLMRec의 추천 성능 향상을 위해 협업 정보 모델링의 중요성을 강조하며, 특히 warm 시나리오에서 그 효과를 부각시킨다.
CoLLM 소개 : CoLLM은 LLMRec을 위한 협업 정보를 통합하는 새로운 접근 방식으로, 전통적인 협업 모델을 LLM에 외부화하여 효과적인 협업 정보 모델링을 보장하고, 모델링 메커니즘을 튜닝하는 유연성을 제공한다.
실험 결과 : 광범위한 실험 결과는 CoLLM의 효과성과 적응성을 입증하며, LLM이 Warm 시나리오와 Cold 시나리오 모두에서 우수한 성능을 발휘할 수 있도록 한다.
미래 연구 방향 :
- 현재 실험은 Vicuna-7B에서만 진행되었으며, 향후 다른 LLM을 탐색할 계획이다.
- 실제 세계에서의 협업 정보의 변화하는 특성을 고려하여 CoLLM의 점진적 학습 능력을 조사할 예정이다.

[논문] On Generative Agents in Recommendation

Thu, 13 Mar 2025 09:04:47 GMT

📄 Paper

On Generative Agents in Recommendation [arxiv]

An Zhang ACM SIGIR 24

📝 Key Point

Agent4Rec의 개발 : Agent4Rec은 추천 시스템을 시뮬레이션하기 위해 설계된 LLM 기반의 생성 에이전트로, 사용자 행동을 모사하는 데 초점을 맞춘다.
사용자 행동 시뮬레이션 : Agent4Rec은 실제 인간의 행동을 효과적으로 시뮬레이션할 수 있는 능력을 보여주었다. 에이전트는 추천된 아이템에 대해 사용자와 유사한 반응을 보였으며, 높은 정확도와 재현율을 유지했다.
필터 버블 효과 재현 : 시뮬레이션 결과, 반복적인 추천 과정에서 영화 추천이 점점 중앙 집중화되는 경향이 나타났다. 장르 다양성은 감소하고, 특정 장르의 지배력은 강화되는 결과를 보였다. 이는 실제 추천 시스템에서 관찰되는 필터 버블 현상을 잘 반영한다.
인과 관계 분석 : 인과 관계 분석 결과, 영화 품질과 인기가 영화 평점에 주요한 영향을 미치는 것으로 나타났다. 높은 노출을 받은 영화는 더 많은 시청과 평점 증가를 유도하며, 이는 인기 편향을 강화하는 피드백 루프를 형성한다.

Abstract

연구 배경 : 추천 시스템은 정보 전파의 핵심이지만, 오프라인 메트릭과 온라인 성능 간의 단절이 발전을 저해한다. 이를 해결하기 위해, LLM의 인간 수준의 지능을 활용한 추천 시뮬레이터를 구상한다.

제안 시스템 : Agent4Rec은 LLM 기반의 생성 에이전트를 사용하는 사용자 시뮬레이터이다. 사용자 프로필, 메모리, 행동 모듈을 추천 시스템에 맞춰 설계하며, 실제 데이터셋을 통해 에이전트의 특성을 초기화한다.

주요 기능 : 에이전트는 개인화된 추천 모델과 페이지 단위로 상호작용하고, 협업 필터링 기반 추천 알고리즘을 사용한다. 이 시스템은 에이전트의 행동을 통해 실제 자율적 인간의 행동을 시뮬레이션할 수 있는 가능성을 탐구한다.

연구 목표 : Agent4Rec의 능력과 한계를 평가하고, 추천 선호 간의 일치 및 편차를 분석한다. 또한, 필터 버블 효과를 모방하고 추천 작업의 인과 관계를 발견하는 통찰력 있는 실험을 진행한다.

Figure

Agent4Rec은 영화 추천 시나리오에서 1,000개의 LLM 기반 생성 에이전트를 사용하는 사용자 시뮬레이터이다. 이 에이전트들은 MovieLens-1M 데이터셋을 기반으로 초기화되며, 다양한 사회적 특성과 선호를 가진다.

각 에이전트는 개인화된 영화 추천을 페이지 단위로 상호작용하며, 여러 가지 행동을 수행한다. 여기에는 영화 시청, 평가, 리뷰, 종료, 인터뷰 등이 포함된다. Agent4Rec을 통해 LLM 기반 생성 에이전트가 추천 환경에서 실제 독립적인 인간의 행동을 시뮬레이션할 수 있는 가능성을 탐구하고자 한다.

Agent4Rec의 전반적인 구조이다. 이 시뮬레이터는 두 가지 핵심 요소로 구성된다. LLM 기반 생성 에이전트(빨간색 섹션)와 추천 환경(파란색 섹션)이다. 사용자와 아이템 프로필은 실제 데이터셋(예: MovieLens-1M, Steam, Amazon-Book)을 사용하여 초기화된다.

추천 알고리즘은 시스템의 적응 가능한 구성 요소로, 에이전트에게 페이지 단위로 제시되는 아이템 추천을 생성한다. 에이전트들은 추천 시나리오에 맞춘 특화된 메모리 및 행동 모듈로 강화되어, 다양한 행동을 시뮬레이션한다. 여기에는 아이템 시청, 평가, 피드백 제공, 다음 페이지로 이동, 시스템 종료, 종료 후 인터뷰 참여 등이 포함된다.

1. Introduction

연구 배경 : 추천 시스템은 현대 정보 전파에서 중요한 역할을 하며 개인의 선호와 인지 과정을 형성한다. 그러나 기존의 감독형 추천 접근 방식은 오프라인 메트릭과 온라인 성능 간의 큰 격차로 인해 한계를 드러내며, 이는 학술 연구와 실제 추천 배포 간의 통합을 저해한다. 이러한 문제를 해결하기 위해, 사용자 의도를 충실히 포착하고 인간 인지 메커니즘을 인코딩하는 시뮬레이션 플랫폼의 필요성이 대두된다.

제안 시스템 : Agent4Rec은 LLM 기반 생성 에이전트를 사용하는 일반 사용자 시뮬레이터로, 추천 환경 내에서 1,000개의 에이전트를 시뮬레이션한다. 각 에이전트는 실제 데이터셋을 기반으로 초기화되며, 사용자 프로필, 메모리, 행동 모듈로 구성된다. 프로필 모듈은 개인화된 사회적 특성과 과거 선호를 저장하고, 메모리 모듈은 과거 시청 행동과 감정적 기억을 기록하여 정보 검색 및 감정 기반 반영을 가능하게 한다. 행동 모듈은 추천 환경과 상호작용하며 다양한 행동을 수행한다.

추천 알고리즘 : 에이전트는 사전 정의된 추천 알고리즘을 통해 페이지 단위로 아이템을 추천받으며, 주로 협업 필터링 기반 전략을 통합한다. 시뮬레이터는 개방형 인터페이스를 제공하여 연구자와 실무자가 원하는 추천 알고리즘을 쉽게 배포할 수 있도록 설계되었다.

평가 방법 : Agent4Rec의 효과성과 한계를 평가하기 위해 사용자와 추천 시스템의 관점에서 포괄적인 실험을 수행한다. 사용자의 관점에서는 에이전트의 일치 정도를 평가하고, 추천 시스템의 관점에서는 다양한 알고리즘으로 구성된 추천자들을 평가한다. 평가 지표는 추천된 아이템 수, 사용자 평점, 사용자 참여 시간, 전반적인 사용자 만족도를 포함한다.

실험 : 두 가지 실험을 통해 추천 작업의 해결되지 않은 문제를 탐구한다. 첫 번째 실험에서는 필터 버블 효과를 모방하여 중앙집중화된 추천 현상을 이해하고, 두 번째 실험에서는 데이터 수집 도구로서의 역할을 하여 인과 관계를 발견한다.

기여 :

LLM 기반 에이전트를 활용한 추천 시뮬레이터 Agent4Rec을 개발하여 사용자 개인화된 선호와 행동 패턴을 모사한다.
Agent4Rec의 능력과 한계를 평가하고, 오프라인 성능과 시뮬레이션 피드백을 고려한 이중 평가 방식을 제안한다.
Agent4Rec을 데이터 수집 도구로 활용하여 필터 버블 효과를 재현하고 추천 시스템 시나리오 내의 인과 관계를 밝혀낸다.

Agent4Rec은 최첨단 기술과 추천 시스템의 도전 과제 사이의 교차점에 위치하며, 이 연구 방향에서 더 많은 연구를 촉진할 수 있는 실험 플랫폼을 제공한다.

2. Agnet4Rec

Agent4Rec은 추천 시나리오에서 사용자 시뮬레이션을 수행하며, 사용자 행동을 정확하게 반영하고 장기적인 사용자 선호를 효과적으로 예측하며 추천 알고리즘을 체계적으로 평가하는 것을 목표로 한다. 이를 위해 두 가지 핵심 요소를 고려한다 :

에이전트 아키텍처 설계 : 사용자 개인화된 선호와 인간의 인지적 추론을 충실히 모사하는 에이전트 아키텍처를 설계한다.
추천 환경 구축 : 신뢰성, 확장성, 적응성을 보장하는 추천 환경을 구축한다.

Agent4Rec은 LangChain을 수정하여 개발되었고, 모든 에이전트는 ChatGPT의 gpt-3.5-turbo 버전으로 구동된다.

Task Formulation

사용자 $u \in U$와 아이템 $i \in I$가 주어졌을 때, $y_{ui} = 1$은 사용자가 아이템 $i$와 상호작용을 했고, 이후 $r_{ui} \in {1, 2, 3, 4, 5}$로 평가했음을 나타낸다. 반대로, $y_{ui} = 0$은 사용자가 해당 아이템을 채택하지 않았음을 의미한다. 각 아이템 $i$의 품질은 다음과 같이 표현된다:

$$R_i = \frac{1}{\sum_{u \in U} y_{ui}}\sum_{u \in U} y_{ui} \cdot r_{ui}$$

아이템의 인기도는 $P_i$로 나타내며, 아이템의 장르 집합은 $G_i \subset G$로 주어진다. 시뮬레이터의 궁극적인 목표는 사용자가 보지 않은 추천 아이템 $i$에 대한 진정한 선호 $\hat{y}{ui}$와 평가 $\hat{r}{ui}$를 충실히 추출하는 것이다.

2.1 Agent Architecture

Agent4Rec의 생성 에이전트는 LLM을 기반으로 하여 추천 시나리오에 맞춘 세 가지 전문화된 모듈(프로필 모듈, 메모리 모듈, 행동 모듈)을 통해 기능을 향상시킨다. 특히, 개인화된 진정한 인간 행동을 모사하기 위해 각 에이전트는 개인화된 사회적 특성과 선호를 반영하는 사용자 프로필 모듈을 통합한다. 또한, 인간의 인지 과정을 모델링하여 과거 상호작용과 감정을 저장, 검색 및 적용하여 일관된 행동을 생성할 수 있도록 메모리 및 행동 모듈이 장착된다.

2.1.1 Profile Module

개인화된 추천 시뮬레이션 분야에서 사용자 프로필 모듈은 에이전트의 진정한 인간 행동과의 일치를 보장하는 중요한 역할을 한다. 생성 에이전트의 후속 시뮬레이션 및 평가를 위한 신뢰할 수 있는 기반을 마련하기 위해, MovieLens-1M, Steam, Amazon-Book과 같은 벤치마크 데이터셋을 초기화에 사용한다. 각 에이전트의 프로필은 두 가지 구성 요소(사회적 특성과 고유한 취향)로 이루어진다.

사회적 특성 (Social Traits) : 세 가지 주요 특성(활동, 순응, 다양성)을 포함하며, 추천 시나리오에서 개인의 성격과 특성을 포착한다.
- 활동 : 사용자가 추천 아이템과 상호작용하는 빈도와 폭을 정량화한다. 에이전트의 활동 특성은 다음과 같이 정의된다:
  
  $$T_{act}^{u} = \sum_{i \in I} y_{ui}$$
- 순응 : 사용자의 평가가 평균 아이템 평가와 얼마나 일치하는지를 설명하며, 독립적인 관점을 가진 사용자와 대중적인 의견에 가까운 사용자를 구분한다. 사용자 $u$의 순응 특성은 다음과 같이 정의된다:
  
  $$T_{conf}^{u} = \frac{1}{\sum_{i \in I} y_{ui}}\sum_{i \in I} y_{ui} \cdot |r_{ui} - R_i|^2$$
- 다양성 : 사용자가 다양한 장르의 아이템에 얼마나 선호를 두는지를 반영한다. 사용자 $u$의 다양성 특성은 다음과 같이 정의된다:
  
  $$T_{div}^{u} = |\bigcup_{i \in {y_{ui}=1}} G_i|$$
사용자는 일반적으로 이러한 사회적 특성에서 특정 분포를 보이며, 이를 기반으로 각 특성에 따라 세 가지 불균형 계층으로 분류한다.
고유한 취향 (Unique Tastes) : 각 사용자에 대해 시청 기록에서 무작위로 25개 아이템을 선택하여 자연어로 개인화된 선호를 인코딩한다. 평점이 3 이상인 아이템은 '좋아함'으로, 3 미만인 아이템은 '싫어함'으로 분류한다. ChatGPT를 활용하여 사용자가 보인 고유한 취향과 평가 패턴을 요약하여 프로필에 포함시킨다. 이러한 개인화된 아이템 취향은 사용자 프로필에 두 번째 구성 요소로 통합된다.

Agent4Rec에서는 개인 식별자(이름, 성별, 나이, 직업 등)를 의도적으로 숨겨서 개인정보 보호 문제를 해결하고, 널리 적용 가능성을 보장한다. 이러한 속성들은 다른 유형의 에이전트를 형성하는 데 유용할 수 있지만, 추천의 범주에서는 사용자의 아이템 선호를 지배하지 않는다. 선호는 과거 시청 기록, 평가 패턴, 사용자 상호작용에 내재된 통찰을 통해 충분히 유추할 수 있다.

2.1.2 Memory Module

인간은 다양한 기억을 보유하며, 주로 사실적 기억과 감정적 기억으로 구분된다. 이 중 감정적 기억은 개인의 역사에서 핵심적인 역할을 하며, 의사결정에 더 강한 영향을 미친다. 기존 연구들은 에이전트의 메모리 구조를 상세히 설명하였으나, 감정적 기억은 대체로 간과되었다.

Agent4Rec에서는 각 생성 에이전트 내에 전문화된 메모리 모듈을 내장하여 사실적 기억과 감정적 기억을 기록한다. 추천 작업에 맞춰 설계된 사실적 기억은 추천 시스템 내에서의 상호작용 행동을 포함하고, 감정적 기억은 이러한 상호작용에서 발생하는 심리적 감정을 포착한다.

사실적 기억 : 추천된 아이템 목록과 사용자 피드백을 포함한다. 피드백은 사용자가 아이템을 시청했는지, 해당 아이템에 대한 평점, 종료 행동 등을 포함한다.
감정적 기억 : 시스템 상호작용 중 사용자의 감정을 기록하며, 피로도 및 전반적인 만족도와 같은 요소를 포함한다. 이는 생성 에이전트가 단순히 과거의 사실적 상호작용에만 반응하는 것이 아니라, 감정도 고려하여 진정한 인간 행동을 더욱 잘 모사하도록 한다.

메모리는 자연어 설명과 벡터 표현의 두 가지 형식으로 저장된다. 자연어 설명은 인간이 이해하기 쉽게 설계되었으며, 벡터 표현은 효율적인 기억 검색과 추출을 위해 최적화된다.

에이전트가 추천 환경과 상호작용할 수 있도록 세 가지 메모리 작업을 도입한다.

메모리 검색 (Memory Retrieval) : 이전 연구의 통찰을 바탕으로, 이 작업은 에이전트가 메모리 모듈에서 가장 관련성 높은 정보를 추출하도록 돕는다.
메모리 기록 (Memory Writing) : 에이전트가 시뮬레이션한 상호작용 및 감정을 메모리 스트림에 기록할 수 있게 한다.
메모리 반영 (Memory Reflection) : 추천에서 감정이 사용자 행동에 미치는 영향을 인식하고, 감정 기반 자기 반영 메커니즘을 통합한다. 이는 기존 에이전트 메모리 설계(예: 자기 요약, 자기 검증, 자기 수정)와는 대조적이다. 에이전트의 행동이 미리 정의된 횟수를 초과하면 반영 과정이 시작된다. LLM의 능력을 활용하여 에이전트는 추천에 대한 만족도와 피로도를 introspect(내성적으로 성찰)하며, 자신의 인지 상태에 대한 더 깊은 이해를 제공한다.

2.1.3 Action Module

에이전트에 사용자 프로필과 메모리 모듈을 장착함으로써, 에이전트는 현재 관찰에 기반하여 인간과 유사한 다양한 행동을 보일 수 있다. Agent4Rec에서는 추천 도메인에 특화된 행동 모듈을 설계하였으며, 이는 두 가지 주요 범주의 행동을 포함한다:

취향 기반 행동 (Taste-driven Actions) : 아이템을 시청하고 평가하며, 시청 후 감정을 생성하는 행동이다. Agent4Rec에서는 추천 알고리즘에 의해 생성된 추천 아이템이 페이지 단위로 에이전트에게 제시된다. 에이전트는 각 페이지의 아이템을 자신의 선호와 일치하는지 평가하며, 관심 있는 아이템은 시청하고 나머지는 건너뛸 수 있다. 시청한 각 아이템에 대해 평점과 감정을 제공한다.
감정 기반 행동 (Emotion-driven Actions) : 추천 시스템을 종료하고 평가하며, 종료 후 인터뷰를 진행하는 행동이다. 추천 환경에서의 감정은 에이전트의 경험에 큰 영향을 미치며, 이는 시뮬레이션에서 종종 간과된다. 에이전트는 이전 추천 아이템에 대한 만족도와 현재의 피로도가 다음 추천 페이지를 탐색할지 또는 추천 시스템을 종료할지를 결정하는 데 영향을 미친다. 이러한 다면적인 의사결정을 보다 잘 시뮬레이션하기 위해, 우리는 Chain-of-Thought를 통해 에이전트의 감정적 추론 능력을 강화한다. 에이전트는 먼저 현재 추천 페이지를 인식하고 감정적 기억에서 이전 추천에 대한 만족도를 검색한다. 이후 에이전트는 현재 추천 페이지에 대한 만족도와 피로도를 자율적으로 표현한다. 이러한 통찰을 바탕으로, 개인화된 활동 특성과 결합하여 시스템을 종료할지 결정한다.

종료 후, 각 에이전트와 인터뷰를 실시하여 추천 시스템에 대한 평점과 전반적인 인상을 포착하고, 시스템 내 탐색 중 자신의 행동에 대한 명확한 설명을 제공한다. 이러한 인터뷰 스타일의 피드백은 전통적인 메트릭에서 얻은 통찰을 보강하며, 보다 풍부하고 인간이 이해할 수 있는 평가를 가능하게 한다.

Chain-of-Thought (CoT)

Chain-of-Thought는 인공지능 모델이 문제를 해결하거나 질문에 답할 때, 각 단계의 사고 과정을 명시적으로 설명하도록 하는 방법론이다. 이 접근법은 모델이 단순한 최종 답변을 제공하는 것이 아니라, 문제 해결 과정에서의 논리적 추론을 단계적으로 나열하게 함으로써 더 나은 이해와 투명성을 제공하는 데 목적이 있다.

Chain-of-Thought의 장점

논리적 추론 강화 : 모델이 문제를 해결하는 과정을 명시적으로 설명함으로써, 더 복잡한 문제를 해결할 수 있는 능력을 향상시킬 수 있다.
투명성 : 사용자는 모델이 어떻게 결론에 도달했는지를 이해할 수 있어, 결과에 대한 신뢰성을 높일 수 있다.
오류 분석 : 각 단계에서의 사고 과정을 명시함으로써, 모델의 오류를 더 쉽게 식별하고 개선할 수 있다.

2.2 Recommendation Environment

Agent4Rec는 에이전트와 추천 환경 간의 상호작용을 시뮬레이션하며, 실제 시나리오와 유사한 환경 구축의 세 가지 주요 측면을 논의한다: 아이템 프로필 생성, 페이지 단위 추천 시나리오, 추천 알고리즘 설계.

1. Item Profile Generation (아이템 프로필 생성)

아이템 특성 : 아이템의 품질, 인기도, 장르 및 요약을 포함하는 프로필을 생성한다.
- 품질 : 과거 평점에 기반하여 결정된다.
- 인기도 : 리뷰 수에 따라 판단된다.
- 장르 및 요약 : LLM을 통해 생성된다.
목표 : 아이템의 고유성을 프로필에 담는 것을 넘어 실제 사용자 추천 장면을 시뮬레이션한다. LLM의 환각 가능성을 테스트하기 위해, 아이템을 18개 장르 중 하나로 분류하고 요약을 생성하는 few-shot learning 접근법을 활용한다.
신뢰성 유지 : LLM이 잘못 분류한 아이템은 제거하여 환각의 위험을 줄이고, 시뮬레이션의 신뢰성을 높인다.

Few-shot prompting

Few-shot prompting은 LLM이 새로운 작업을 수행할 때 몇 가지 예시를 제공하여 모델이 작업의 맥락과 요구 사항을 더 잘 이해하도록 돕는 기술이다. 이 방법은 모델이 더 정확하고 구조화된 출력을 생성하게 하는 데 매우 효과적이다.

작업 구성 요소
- 작업 (Instructions) : 모델이 수행해야 할 작업에 대한 설명
- 예시 (Examples) : 모델이 참고할 수 있는 예시들
- 입력 데이터 (Input data) : 분석할 데이터로, 선택적으로 활용됨

2. Page-by-Page Recommendation Scenario (페이지 단위 추천 시나리오)

작동 방식 : 실제 추천 플랫폼(e.g. Netflix, YouTube, Douban)의 운영을 모방하여 페이지 단위로 기능한다.
사용자 경험 : 각 페이지에서 추천된 아이템 목록을 제시하고, 사용자의 상호작용, 선호도, 피드백에 따라 후속 페이지의 추천이 조정된다.
목표 : 더 정교한 사용자 경험 제공을 위해 추천을 맞춤화한다.

3. Recommendation Algorithm Designs (추천 알고리즘 설계)

독립 모듈 : 추천 알고리즘은 독립적인 모듈로 구성되며, 확장성에 중점을 둔다.
협업 필터링 전략 : 무작위, 가장 인기 있는 아이템, Matrix Factorization (MF), LightGCN, MultVAE와 같은 사전 구현된 전략을 포함한다.
열린 인터페이스 : 외부 추천 알고리즘을 쉽게 통합할 수 있는 인터페이스를 제공하여, 연구자와 실무자가 다양한 알고리즘을 활용할 수 있도록 한다.
목표 : Agent4Rec을 포괄적인 평가와 가치 있는 사용자 피드백 수집을 위한 다목적 플랫폼으로 만들기 위해 설계되었다.

3. Agent Alignment Evaluation

RQ1 : LLM 기반 생성 에이전트가 추천 시스템에서 실제 독립적인 인간의 행동을 얼마나 잘 시뮬레이션할 수 있는가?

이 섹션에서는 생성 에이전트의 능력과 한계를 다양한 관점에서 분석한다. 여기에는 사용자 행동의 일치(사용자 취향, 평점 분포 및 사회적 특성 등)와 추천 환경의 평가(추천 전략 평가, 페이지 단위 추천 개선 및 인터뷰 사례 연구 등)가 포함된다.

Motivation

생성 에이전트는 추천된 아이템에 적절히 응답하기 위해 자신의 선호를 명확히 이해해야 한다.
독립적이고 개인화된 에이전트가 MovieLens-1M의 실제 사용자로부터 초기화되었을 때, 장기적인 선호 일관성을 유지해야 한다고 가정한다.
이는 에이전트가 실제 사용자가 선호하는 아이템을 구별할 수 있어야 함을 의미한다.

Setting

생성 에이전트가 사용자 프로필에 인코딩된 선호와 얼마나 잘 일치하는지를 검증하기 위해, 에이전트에게 해당 사용자와 상호작용한 아이템과 하지 않은 아이템을 구별하도록 한다.
세 가지 실제 데이터셋(즉, Movielens-1M, Steam, Amazon-Book)을 사용하여 실험을 수행한다.
1,000개의 에이전트가 각각 20개의 아이템을 무작위로 할당받으며, 이 중 사용자가 상호작용한 아이템과 하지 않은 아이템의 비율을 1:𝑚(𝑚 ∈ {1, 2, 3, 9})로 설정한다.
에이전트의 응답(즉, 𝑦ˆ𝑢𝑖)은 추천된 아이템에 대한 이진 판별로 간주된다.

Results

생성 에이전트는 사용자 선호와 일치하는 아이템을 일관되게 식별한다. 특히, 방해 아이템의 수에 관계없이 에이전트는 약 65%의 높은 정확도와 75%의 재현율을 유지한다. 이러한 높은 충실도는 개인화된 프로필이 사용자의 진정한 관심사를 충실히 반영하기 때문이다.
에이전트는 선호 아이템의 수를 상대적으로 일관되게 유지하는 경향이 있으며, 이는 LLM의 고유한 환각에서 기인할 수 있다. 정확도와 재현율은 만족스러운 결과를 보이나, 정밀도와 F1 점수는 사용자 선호 아이템의 비율이 감소함에 따라 급격히 감소한다. 이는 LLM의 고유한 환각으로 인해 에이전트가 일정 수의 아이템을 지속적으로 선택하는 경향이 있음을 보여준다.

3.1 Rating Distribution Alignment (평점 분포 일치)

Motivation
- 각 에이전트의 미시적 사용자 행동 일치를 보장하는 것 외에도, 생성 에이전트가 실제 사용자 행동 패턴을 거시적으로 반영해야 한다. 특히, 평점 분포에서 MovieLens-1M 데이터 분포와의 일치를 목표로 한다.
Results
- (a)는 Movielens-1M 데이터셋의 실제 평점 분포를 보여주고, (b)는 에이전트가 생성한 평점 분포를 보여준다. - 두 분포 간의 강한 일치를 나타내며, 4점 평점이 전체 분포에서 우세하고, 낮은 평점(1-2)은 소수에 불과하다. - 에이전트는 1-2 평점을 매우 적게 주며, 이는 실제 인간 행동과 다르다. 이는 LLM의 영화에 대한 폭넓은 사전 지식으로 인해 발생하며, 에이전트가 저품질 영화를 피하는 경향이 있다.

Motivation
- 실제 추천 시나리오에서 사용자 행동 패턴은 개인적 선호뿐만 아니라 활동성, 동조성, 다양성과 같은 사회적 속성의 영향을 받는다. 따라서 Agent4Rec의 사용자 프로필에는 이러한 사회적 특성이 포함된다. 활동성, 동조성, 다양성과 같은 사회적 특성은 MovieLens 데이터셋의 통계 정보를 기반으로 높음(high), 중간(medium), 낮음(low)의 세 가지 수준으로 분류한다.
Results
- 다양한 측면에서 사용자 프로필 모듈의 설계 중요성을 검증한다.
1. 서로 다른 계층에 분류된 에이전트의 행동 차이
2. 사회적 특성이 있는 에이전트와 없는 에이전트 간의 차이
3. 에이전트의 특성 분포가 실제 사용자와 일치 여부
- 실험 결과는 사회적 특성이 사용자 프로필 구성에서 중요한 역할을 하며, 에이전트 행동에 크게 영향을 미친다는 것을 보여준다.
- 다양성 특성은 영화 카테고리의 강한 중복으로 인해 차이가 미미할 수 있으며, 이는 추가 연구가 필요함을 시사한다.

3.3 Recommendation Strategy Evaluation (추천 전략 평가)

Motivation
- 인간 사용자들은 다양한 추천 알고리즘에 대해 서로 다른 만족도를 보인다. 생성 에이전트가 실제 인간 행동을 정확히 시뮬레이션할 수 있다면, 이들이 보여주는 만족도 경향도 유사할 것이다.
Setting
- 협업 필터링 기반 추천 전략(무작위, 인기, MF, LightGCN, MultVAE)을 사용하여 MovieLens에서 만족도 경향을 평가한다.
- 에이전트는 각 추천 페이지에서 4개의 영화를 보고 개인 선호에 따라 행동하며, 최대 5페이지를 탐색한 후 추천 시스템에 대한 만족도를 1에서 10까지 평가한다.
Results
- $\overline{P}_{view}$ : Average Viewing Ratio $\overline{N}_{like}$ : Average Number of Likes $\overline{P}_{like}$ : Average Ratio of Likes $\overline{N}_{exit}$ : Average Number of Exit Pages $\overline{S}_{sat}$ : Average User Satisfaction Score
- 에이전트는 알고리즘 기반 추천에 대해 무작위 및 인기 기반 추천보다 높은 만족도를 보인다.
- LightGCN이 MF 및 MultVAE보다 다양한 평가 기준에서 우수한 성과를 보이며, 이는 LLM 기반 에이전트의 세밀한 평가 능력을 강조한다.
- 이러한 결과는 에이전트 기반 추천 시뮬레이터가 A/B 테스트에 대한 비용 효율적인 대안을 제공할 가능성을 제시한다.

3.4 Page-by-Page Recommendation Enhancement (페이지 단위 추천 개선)

Motivation
- 추천 플랫폼은 사용자 행동을 실시간으로 수집하여 추천 시스템을 반복적으로 개선한다. 페이지 단위 추천 설정을 통해 이러한 피드백 기반 추천 개선을 모사하고자 한다.
Setting
- 추천 시뮬레이션 후 각 에이전트의 조회 및 미조회 영화를 긍정적인 신호로 활용하여 추천 알고리즘을 재훈련한다. 재훈련된 추천 시스템의 성능을 표준 오프라인 메트릭(Recall@20, NDCG@20)과 만족도 평가로 평가한다.
Results
- 에이전트가 조회한 영화를 활용하여 모든 추천 알고리즘이 오프라인 평가 메트릭과 만족도 평가에서 개선됨을 보여준다. - 그러나 미조회 영화를 추가하면 전반적인 사용자 경험이 저하되는 경향이 있다. 이는 에이전트의 영화 선택이 사용자 선호의 일관된 지표가 될 수 있음을 나타낸다.

3.5 Case Study of Feeling Interview (감정 인터뷰 사례 연구)

Motivation
- LLM 기반 에이전트 시뮬레이션의 독특한 강점은 인간이 이해할 수 있는 설명을 제공할 수 있다는 점이다. 에이전트로부터 설명을 이끌어내면 시뮬레이션의 신뢰성을 평가하고 추천 시스템을 개선하는 데 도움이 된다.
Results
- 그림 7은 MovieLens에서의 사후 인터뷰 사례를 보여준다. 에이전트는 개인적인 취향, 사회적 특성, 감정 기억에 따라 추천 영화를 평가한다.
- 에이전트는 추천 시스템이 자신의 선호에 맞는 영화를 제안했음을 인식하지만, 만족도를 낮추는 요소도 존재한다고 언급한다. 예를 들어, 다양한 관심사를 가지고 있음에도 불구하고 시스템이 인기 영화를 추천하는 경향이 있다.

4. Insights and Exploration

RQ2 : Agent4Rec이 추천 분야의 해결되지 않은 문제에 대한 통찰을 제공할 수 있는가?

4.1 Filter Bubble Effect (필터 버블 효과)

Motivation
- 필터 버블 효과는 추천 시스템에서 널리 퍼진 문제로, 알고리즘 기반 추천자가 사용자 피드백 루프를 기반으로 사용자가 선호할 영화를 예측함으로써 발생한다. 이로 인해 점점 동질적인 추천 콘텐츠가 생성된다. 우리의 주요 목표는 Agent4Rec이 필터 버블 현상을 재현할 수 있는 능력을 평가하는 것이다.
Setting
- 공정성을 위해 MovieLens의 영화 풀을 네 개의 동일한 부분으로 나누고, MF 기반 추천자가 네 번의 완전한 시뮬레이션 라운드를 거치도록 한다. 각 라운드에서 추천된 영화는 최대 5페이지에 걸쳐 있으며, 각 시뮬레이션 라운드 후에 MF 기반 추천자가 재훈련된다. 필터 버블 효과는 개별 사용자 수준에서 콘텐츠 다양성을 기반으로 평가한다.
- 두 가지 메트릭이 사용된다.
- $P_{top1-genre}$* : 추천 영화 중 가장 많이 추천된 장르의 평균 비율.
- $N_{genres}$* : 각 시뮬레이션에서 추천된 장르의 평균 개수.
Results
- 위 그래프는 반복 횟수가 증가함에 따라 영화 추천이 더 중앙 집중화되는 경향을 보여준다. 구체적으로, 장르 다양성($N_{genres}$)은 감소하고, 주 장르의 지배력($P_{top1-genre}$)은 강화된다. 이 결과는 Agent4Rec이 실제 추천 시스템에서 일반적으로 관찰되는 필터 버블 효과를 반영할 수 있음을 입증한다.

Filter Bubble Effect (필터 버블 효과)

필터 버블 효과는 개인화된 추천 시스템이나 알고리즘이 사용자의 과거 행동, 선호, 검색 기록 등을 기반으로 정보를 제공할 때 발생하는 현상이다. 이 과정에서 사용자는 자신이 선호하는 정보나 콘텐츠만 지속적으로 접하게 되어, 다양한 의견이나 관점을 접할 기회를 잃게 된다.
즉, 사용자가 특정한 정보에만 노출되면서 그 정보의 범위가 좁아지고, 결과적으로 정보의 다양성이 감소하게 된다. 이로 인해 사용자는 자신의 기존 신념이나 의견을 강화하게 되고, 새로운 아이디어나 관점을 수용하기 어려워질 수 있다. 필터 버블 효과는 사회적, 정치적, 문화적 문제와 관련하여 심각한 영향을 미칠 수 있다.

4.2 Discovering Causal Relationships (인과 관계 발견)

Motivation
- 인과 발견은 관찰 데이터를 통해 인과 구조(인과 그래프)를 추론하는 것을 목표로 한다. 이 기법은 특정 분야의 기초 메커니즘을 이해하는 데 중요하다. Agent4Rec이 추천 시스템에서 인과 관계를 밝혀내는 데 기여할 수 있는가를 평가한다.
Setting
- MovieLens에서 영화 평점에 영향을 미치는 요인을 이해하기 위해 각 영화에 대해 에이전트가 시뮬레이션한 평점 외에 네 가지 주요 변수를 수집한다.
- 주요 변수 : 영화 품질, 인기(영화 프로필에서 수집), 노출 비율, 그리고 영화가 시청된 횟수(시뮬레이터에서 수집).
- 이 시뮬레이션된 데이터 내에서 잠재적 인과 관계를 탐구하기 위해 DirectLiNGAM 알고리즘을 사용한다. 이 알고리즘은 가중치가 있는 유향 비순환 그래프(Directed Acyclic Graph, DAG)를 발견한다.
Results
- Movie Rating : 영화 품질과 영화 인기는 영화 평점의 원인이다. 영화 품질이 에이전트 평점에 가장 크게 기여하지만, 영화의 인기 또한 평점에 약간의 영향을 미친다. 이는 실제 상황에서 인간이 인기 있는 영화에 대해 높은 평점을 주는 경향과 일치한다.
- Exposure Rate : 인기 편향을 증폭하는 피드백 루프가 관찰된다. 매우 인기 있는 영화는 더 많은 노출을 받아 에이전트에 의해 더 많이 시청된다. 이러한 인기 아이템이 새로운 훈련 데이터셋에 포함되면, 추천 시스템은 후속 반복에서 이들을 더 많이 노출하는 경향이 있으며, 이는 인기 편향으로 알려져 있다.

DirectLiNGAM 알고리즘

DirectLiNGAM 알고리즘은 인과 관계를 추론하기 위한 방법 중 하나로, 관찰된 데이터를 기반으로 인과 그래프를 구축하는 데 사용된다.

선형 시스템 : DirectLiNGAM은 선형 인과 관계를 가정하며, 변수 간의 관계가 선형적으로 나타날 수 있다고 전제한다.
비순환 그래프 : 이 알고리즘은 가중치가 있는 유향 비순환 그래프(Directed Acyclic Graph, DAG)를 생성하여 변수 간의 인과 관계를 시각적으로 표현한다.
적용 가능성 : DirectLiNGAM은 주로 사회 과학, 생물학, 경제학 등 다양한 분야에서 인과 관계를 분석하는 데 활용된다.
효율성 : 이 알고리즘은 데이터의 인과 구조를 발견하는 데 상대적으로 빠르고 효율적으로 작동하며, 다양한 변수 간의 인과 관계를 명확히 이해하는 데 도움을 줍니다.

6. Limitations and Future Work

1. Datasource Constraints (데이터 소스 제약)

Agent4Rec은 오프라인 데이터셋만을 사용하여 구현되며, 두 가지 주요 요인에 의해 제약을 받는다.
LLM의 사전 지식 필요성 : LLM은 추천된 아이템에 대한 사전 지식이 필요하기 때문에, ID만 있거나 상세한 아이템 설명이 부족한 대부분의 오프라인 데이터셋은 이 작업에 적합하지 않다.
온라인 데이터 : 온라인 데이터는 시뮬레이터와 자연스럽게 일치하여 효과성을 평가하는 데 편향 없는 관점을 제공하지만, 이러한 데이터를 획득하는 것은 상당한 도전 과제이다.

2. Limited Action Space (제한된 행동 공간)

현재 Agent4Rec의 행동 공간은 제한적이며, 사용자 결정에 영향을 미치는 중요한 요소(e.g. 소셜 네트워크, 광고, 입소문 마케팅 등)를 생략하고 있다.
간소화의 장단점 : 이러한 단순화는 간단한 시나리오에서 LLM 기반 에이전트의 신뢰할 수 있는 평가를 촉진하지만, 실제 사용자 의사 결정 과정에서의 격차를 초래한다.
미래 방향 : 향후 작업의 주요 방향은 사용자 행동의 다면적 특성을 더 잘 포착하기 위해 영향력 있는 요인의 범위를 넓혀, 시뮬레이션이 추천 시나리오를 보다 보편적으로 대표할 수 있도록 하는 것이다.

3. Hallucination in LLM (LLM의 환각)

시뮬레이션에서 간헐적인 환각 현상이 관찰되었다. 예를 들어, LLM이 부정적인 평점을 주는 인간 사용자를 정확하게 시뮬레이션하지 못하거나, 존재하지 않는 아이템을 만들어내고 이를 평가하거나, 요구된 출력 형식을 준수하지 않는 경우가 있다.
결과적 영향 : 이러한 불일치는 부정확한 시뮬레이션 결과로 이어질 수 있다.
미래 목표 : 이러한 관찰을 고려하여, 추천 시나리오에서 사용자 행동을 시뮬레이션하기 위해 특별히 LLM을 미세 조정하여 시뮬레이터의 안정성과 정확성을 향상시키는 것이 향후 목표이다.

[논문] AgentCF: Collaborative Learning with Autonomous Language Agents for Recommender Systems

Thu, 06 Mar 2025 15:09:05 GMT

📄 Paper

AgentCF: Collaborative Learning with Autonomous Language Agents for Recommender Systems [arxiv]

Junjie Zhang ACM WWW 24

📝 Key Point

AgentCF 제안 : 사용자와 아이템을 모두 에이전트로 설정하여, LLM 기반 에이전트 간의 상호작용을 통해 사용자-아이템 관계를 모델링하는 새로운 협업 필터링 접근법을 제안하였다.
Collaborative 학습 : 사용자 및 아이템 에이전트를 함께 최적화하여 자율적인 상호작용을 수행하고, 이 과정에서 선호 정보를 서로 전파함으로써 협업 필터링의 개념을 암묵적으로 모델링하였다.
인간 유사 행동 : 시뮬레이션된 에이전트가 다양한 상호작용(사용자-아이템, 사용자-사용자, 아이템-아이템 등)에서 인간과 유사한 행동을 보이며, 효과성을 입증하였다.

Abstract

배경
- LLM 기반 에이전트를 신뢰할 수 있는 인간 대리자로 활용하는 연구가 증가하고 있다.
- 기존 연구는 주로 인간 대화 시뮬레이션에 집중하고 있다.
- 사용자 선호를 암시적으로 나타내는 비언어적 행동(예: 클릭)은 충분히 탐구되지 않았다.
문제점
- 언어 모델링과 행동 모델링 간의 간극이 존재한다.
- LLM이 사용자-아이템 관계를 이해하지 못한다.
제안
- AgentCF : 추천 시스템에서 사용자-아이템 상호작용을 시뮬레이션하기 위한 방법이다.
- 사용자와 아이템을 모두 에이전트로 간주한다.
- 두 종류의 에이전트를 함께 최적화하는 Collaborative 학습 접근 방식을 개발하였다.
방법론
- 각 시간 단계에서 사용자와 아이템 에이전트가 자율적으로 상호작용하도록 유도한다.
- 에이전트의 결정과 실제 상호작용 기록 간의 차이를 바탕으로 Collaborative하게 조정한다.
결과
- 최적화된 에이전트는 다음 상호작용에서 다른 에이전트에게 자신의 선호를 전파한다.
- 다양한 상호작용 행동(사용자-아이템, 사용자-사용자, 아이템-아이템, 집단 상호작용)을 나타낸다.
- 이러한 에이전트는 실제 개인과 유사한 개인화된 행동을 보여주며, 차세대 사용자 행동 시뮬레이션 발전에 기여할 수 있다.

Figure

(1) 사용자와 아이템 에이전트가 자율적으로 상호작용하도록 프롬프팅된다.

(2) 에이전트는 자신의 결정과 실제 상호작용 간의 차이를 반영하여 기억 속의 오개념를 조정한다. 이 과정에서 사용자와 아이템 에이전트의 시뮬레이션된 선호가 집계되며, 이후 상호작용에서 다른 에이전트에게 전파될 수 있다.

1. Introduction

배경
- LLM의 발전으로 LLM 기반 에이전트가 자율적 상호작용 및 의사결정에서 인상적인 능력을 보여준다.
- 에이전트의 수를 늘리면 개인 및 집단 수준에서 인간과 유사한 행동이 나타날 수 있다.
- 이러한 관찰은 LLM 기반 에이전트를 활용하여 인간의 사회적 행동을 시뮬레이션할 수 있는 가능성을 강조한다.
문제 인식
- 기존 연구는 주로 LLM의 의미적 지식을 활용하여 인간 대화 시뮬레이션에 집중하고 있다.
- 그러나 실제 인간 행동은 사용자-아이템 상호작용과 같은 비언어적 측면을 포함하며, 이는 사용자 선호를 반영하고 개인화된 사용자 모델링에 기여할 수 있다.
- 상호작용 기록을 자연어 텍스트로 변환하여 LLM을 유도하는 방법은 이러한 상호작용의 기본 행동 패턴을 포착하는 데 한계가 있다.
연구의 초점
- 추천 시스템을 연구 대상으로 삼아 LLM 기반 에이전트로 사용자-아이템 상호작용을 시뮬레이션하는 방법을 고려한다.
- 기존 연구는 사용자 측 행동을 특성화하는 데 중점을 두고, 아이템 측 모델링의 영향을 간과하고 있다.
제안된 접근법
- 협업 필터링 아이디어에서 영감을 받아 사용자와 아이템을 모두 에이전트로 간주하고, 두 에이전트를 함께 최적화하는 방법을 개발한다.
- 사용자와 아이템 에이전트를 자율적으로 상호작용하게 유도하고, 상호작용 기록에 기반하여 collaborative한 반영 메커니즘을 설계한다.
방법의 장점
- 사용자-아이템 상호작용을 자율적 상호작용으로 모델링하여 단순한 텍스트화 과정을 피한다.
- 사용자와 아이템 에이전트를 상호 최적화하여 two-sided 관계를 포착한다.
연구 기여
- 사용자와 아이템을 에이전트로 고려하여 추천 시스템을 위한 사용자-아이템 상호작용 시뮬레이션 접근법을 개발한다.
- 사용자 및 아이템 에이전트를 collaborative하게 최적화하고, 메모리의 상호 업데이트를 달성하는 반영 메커니즘을 설계한다.
- 실제 데이터셋에 대한 광범위한 실험을 통해 개인화된 상호작용 시뮬레이션의 효과성을 입증한다.

2. Methodology

AgentCF는 에이전트 기반 협업 필터링 접근법이다. 이 접근법은 사용자 에이전트와 아이템 에이전트가 추천 시스템에서 사용자-아이템 상호작용으로부터 collaborative하게 학습할 수 있도록 한다.

2.1 Preliminaries

Traditional Recommendation Setting

추천 시스템에는 사용자 집합 $U = {u}$, 아이템 집합 $I = {i}$, 그리고 이들의 상호작용 기록 집합 $D = {⟨u, i⟩}$가 존재한다.
추천을 수행하기 위해, 사용자 $u$가 아이템 $i$에 대한 선호 정도를 포착하는 선호 함수 $f(u, i)$가 구축된다.
상호작용한 아이템(positive item, $i^+$)은 사용자와 상호작용하지 않은 아이템(negative item, $i^-$)보다 높은 점수를 받는다.
예를 들어, BPR은 두 후보 아이템에 대한 선호도를 비교하는 개인화된 pairwise 순위 모델을 구축하고, NCF는 신경망을 사용하여 사용자-아이템 상호작용 관계를 적합시킨다.
선호 함수 $f(u, i)$의 학습은 머신러닝에서 표준적인 gradient 기반 함수 적합 문제로 변환될 수 있다.

Our Task Setting

본 연구는 위의 전통적인 추천 설정을 따르며, LLM 기반 에이전트를 추천 시스템에 통합한다.
이전 연구와는 달리, 아이템 에이전트도 포함되어 제안한 접근법에서 중요한 역할을 한다.
사용자 에이전트 $u$는 해당 실제 사용자의 선호를 포착하고, 아이템 에이전트 $i$는 해당 아이템의 특성과 잠재적 수용자의 선호를 반영한다.
사용자-아이템 상호작용은 사용자와 아이템 에이전트 간의 자율적 상호작용을 통해 시뮬레이션된다.
본 연구에서는 후보 목록 ${c_1, \cdots, c_n}$에 대해 사용자 LLM 에이전트 $u$를 기반으로 하는 순위 작업을 고려한다.

Overview of AgentCF

에이전트를 구현하기 위해 메모리 메커니즘(i.e. 과거 상태, 행동 및 맥락 저장)과 반영 메커니즘(i.e. 에이전트의 상태나 인식 수정)을 사용한다.
추천 작업은 사용자와 아이템 간의 two-sided 상호작용 관계를 모델링해야 하므로, 아이템 에이전트는 실제 상호작용 시나리오를 시뮬레이션하는 데 중요하다.
본 접근법은 LLM을 추천 시스템에 적응시키는 두 가지 기술적 기여를 포함한다.
- Collaborative 메모리 기반 최적화 : LLM에 사용자의 과거 상호작용을 단순히 제공하는 대신, simulated 사용자와 아이템 에이전트를 상호작용을 통해 정제한다. 각 시간 단계에서 이들 에이전트는 자율적으로 상호작용하고, 결정과 실제 상호작용 기록 간의 차이를 collaborative하게 반영한다.
- 암묵적 선호 전파 : 이전 연구와는 달리, 본 접근법은 사용자 및 아이템 에이전트의 메모리에 각 상호작용 기록을 업데이트한다. 이는 아이템 메모리가 이 아이템과 상호작용한 사용자에게 주입될 수 있게 한다. 새로운 상호작용이 발생할 때, 이후 사용자는 이전 수용자의 선호를 알게 된다. 이 과정은 사용자 측에도 적용 가능하다. 본 접근법은 사용자-아이템 상호작용에서 선호를 전파하여 협업 필터링 아이디어를 모델링한다.

2.2 Collaborative Agent Optimization

2.2.1 Memory Design

LLM 기반 에이전트를 추천 시스템에 맞게 특화하기 위해, 사용자와 아이템 에이전트 모두에 메모리 모듈을 장착한다.

User Memory

사용자 에이전트는 사용자 선호를 반영하는 다양한 정보를 저장하는 메모리 모듈을 갖춘다.
사용자 선호는 동적으로 변화하므로, 각 사용자 에이전트 $u$는 단기 메모리 $M_s^u$와 장기 메모리 $M_l^u$를 갖는다.
- 단기 메모리는 최근 업데이트된 선호를 설명하는 자연어 텍스트이다.
- 장기 메모리는 사용자의 선호 변화를 기록하는 역사적 선호 텍스트의 집합이다.

Item Memory

아이템 에이전트는 자신의 특성과 수용자의 선호를 기록하는 조정 가능한 메모리 모듈을 갖춘다.
각 아이템 에이전트 $i$는 통합 메모리 모듈 $M_i$만을 갖는다. 아이템 정보는 시간에 따라 비교적 안정적이기 때문이다.
아이템 메모리는 아이템의 정체성 정보(e.g. 제목, 카테고리)로 초기화되며, 사용자 선호에 따라 지속적으로 업데이트된다.

2.2.2 Autonomous Interactions for Contrastive Item Selection

목적 : 초기화된 에이전트를 최적화하고 실제 사용자-아이템 상호작용을 시뮬레이션하기 위해, 시뮬레이션된 에이전트와 실제 개인 간의 행동 일치를 탐색한다.
행동 일치 탐색 : 에이전트가 실제 상호작용 기록과 일치하는 결정을 내릴 수 있는지를 시험한다.
아이템 선택 : 사용자 에이전트는 긍정적 아이템 $i^+$와 부정적 아이템 $i^-$의 대조 쌍에서 선택을 수행한다.
편향 도입 : 선택 난이도를 높이기 위해 인기 편향과 위치 편향을 도입하며, 인기 있는 부정적 아이템을 샘플링하고 이를 선택 목록에서 긍정적 아이템 앞에 배치한다.
선택 및 설명 : 사용자 에이전트 $u$는 후보 목록에서 아이템 $i_o$를 선택하고, 이 선택에 대한 설명 $y_{exp}$을 제공한다. 이 과정에서 사용자 메모리에서의 선호와 후보 아이템의 특성을 collaborative하게 고려한다.

2.2.3 Collaborative Reflection and Memory Update

목적 : 에이전트의 결정과 실제 상호작용 데이터를 비교하여 피드백 신호를 생성하고, 이를 통해 사용자 및 아이템 에이전트를 collaborative하게 최적화한다.
gradient 기반 학습 없음 : LLM은 고정되어 있으므로 명시적인 gradient 기반 학습 과정이 없다. 대신 사용자 및 아이템 에이전트의 메모리를 업데이트한다.
Collaborative Reflection : 에이전트의 잘못된 선택에 대해 Collaborative Reflection 메커니즘을 통해 메모리와 행동을 수정한다. 사용자 에이전트는 올바른 선택을 했을 때 그 정확성을 알리고 관련 상호작용 정보를 메모리에 저장한다.
메모리 업데이트 : 잘못된 선택의 경우, 사용자 에이전트와 아이템 에이전트가 자신의 선호와 특성을 조정할 수 있도록 반영 과정을 수행한다. 이는 사용자-아이템 관계의 collaborative한 학습을 강조한다.

2.2.4 Connection with Classical Recommendation Models

추천 시스템의 모델 : BPR, NCF와 같은 다양한 추천 모델이 존재한다. 이들 모델은 사용자 선호와 아이템 특성을 나타내는 파라미터를 설정하고, 이를 사용자-아이템 상호작용 기록에 맞추어 최적화한다.
최적화 과정 모방 : 본 접근법은 전통적인 추천 모델의 최적화 과정을 모방한다. 사용자 및 아이템 메모리는 언어 기반 파라미터(i.e. 임베딩)로 간주되며, Item Selection 과정과 Collaborative Reflection 과정은 추천 모델의 forward preference evaluation(선호 점수 추정)과 backward parameter update(gradient 업데이트) 단계에 해당한다.
협업 필터링 아이디어 : Collaborative Reflection은 사용자 및 아이템 에이전트가 상호작용하고 선호 정보를 집계하여 후속 상호작용에 전파하는 역할을 하며, 이를 통해 협업 필터링 아이디어를 포함한다.

2.3 Agent Interaction Inference

메모리 기반 최적화 이후, 제안한 접근법은 개인화된 사용자 에이전트와 선호를 인식하는 아이템 에이전트를 시뮬레이션할 수 있다.
이러한 시뮬레이션된 에이전트를 활용하여 잠재적인 사용자-아이템 상호작용을 추론하는 방법과 후보 목록 ${c_1, \cdots, c_n}$에 대한 순위 작업을 제시한다.

Basic Prompting Strategy

사용자와 아이템 에이전트가 서로의 관계를 모델링하기 위해 collaborative하게 최적화되었기 때문에, 에이전트의 시뮬레이션된 사용자 선호와 후보 아이템 특성을 기본적인 프롬프트 형태로 LLM에 직접 프롬프팅한다.
이 과정은 LLM이 collaborative recommender로 작동할 수 있게 한다.

$$ R_B = f_{LLM}(M_s^u; {M_{c_1}, \cdots, M_{c_n}}) $$

여기서 $M_s^u$는 사용자 에이전트 $u$의 단기 메모리, ${M_{c_1}, \cdots, M_{c_n}}$는 후보 아이템 에이전트의 메모리, $n$은 후보의 수, $R_B$는 순위 결과를 나타낸다.

Advanced Prompting Strategies

단기 메모리는 사용자 에이전트의 현재 선호를 설명하지만, 장기 메모리에서 후보에 대한 전문화된 선호를 검색하면 더 개인화된 추론을 가능하게 한다.
상호작용 기록이 희소하고 선호 전파가 제한적일 때, 사용자 역사적 상호작용을 프롬프트에 통합하여 LLM이 순차 추천자로 작동할 수 있도록 한다.
이러한 두 가지 개선 전략은 다음과 같이 표현할 수 있다:

$$ R_{B+R} = f_{LLM}(M_r^u; M_s^u; {M_{c_1}, \cdots, M_{c_n}}) \tag{7} $$

$$ R_{B+H} = f_{LLM}(M_s^u; {M_{i_1}, \cdots, M_{i_m}}; {M_{c_1}, \cdots, M_{c_n}}) \tag{8} $$

여기서 $M_r^u$는 후보 아이템의 메모리를 쿼리로 사용하여 사용자 에이전트 $u$의 장기 메모리에서 검색된 전문화된 선호를 나타내고, ${M_{i_1}, \cdots, M_{i_m}}$는 아이템 ${i_1, \cdots, i_m}$와의 역사적 상호작용에 대한 메모리이다.

에이전트를 통한 상호작용 향상

최적화된 사용자 에이전트와 아이템 에이전트를 기반으로, 논문의 방법은 실제 관찰된 다양한 상호작용 행동을 더 잘 시뮬레이션할 수 있다. 예를 들어, 사용자-아이템 상호작용, 사용자의 사회적 행동, 심지어 추천 시스템 내의 집단 행동을 포함한다.
아이템을 에이전트로 활성화함으로써 아이템 간의 더 새롭고 매력적인 상호작용을 창출할 가능성이 있다.
예를 들어, 아이템 간 에이전트 상호작용은 수집된 사용자 선호를 새로운 아이템에 자발적으로 전파하여 아이템 콜드 스타트 시나리오에서 유용할 수 있다.

3. Experiments

3.1 Experimental Setup

3.1.1 Datasets

실험은 Amazon 리뷰 데이터셋의 텍스트 집합인 "CDs and Vinyl"과 "Office Products"로 진행된다.
데이터의 희소성이 협업 필터링 추천자에 미치는 영향을 고려하여, 각 데이터셋에서 두 개의 하위 집합(하나는 밀집, 하나는 희소)을 무작위로 샘플링한다. 각 하위 집합은 100명의 사용자를 포함하며, 다양한 상호작용 시나리오를 탐색한다.
추가 분석 실험에는 밀집 데이터셋을 사용하여 에이전트 간의 상호작용을 더 잘 나타낸다.

3.1.2 Evaluation Metrics

성능 평가를 위해 NDCG@K를 사용하며, 여기서 K는 1, 5, 10으로 설정된다.
기존 연구를 따르며, 평가를 위해 마지막 아이템을 실제 아이템으로 간주하는 leave-one-out 전략을 사용한다.
모델을 랭커로 활용하여 9개의 무작위 샘플 아이템과 함께 타겟 아이템을 순위 매긴다.
모든 테스트 인스턴스에 대해 3회 반복하여 평균 결과를 보고한다.

3.1.3 Baseline Models

BPR : 행렬 분해를 활용하여 사용자와 아이템의 표현을 학습하고 BPR 손실을 최적화한다.
SASRec : 변환기 인코더를 활용하여 사용자 과거 상호작용의 순차적 패턴을 캡처한다.
Pop : 후보를 인기도에 따라 순위 매기며, 이는 상호작용 수로 측정된다.
BM25 : 사용자 과거 상호작용과의 텍스트 유사성에 따라 후보를 순위 매긴다.
LLMRank : ChatGPT를 제로샷 랭커로 사용하여 사용자 순차 상호작용 이력을 조건으로 고려한다.

3.2 Overall Performance

제안한 방법은 대부분의 시나리오에서 다른 기준 모델을 능가하여 개인화된 에이전트를 시뮬레이션하는 collaborative 학습의 효과를 강조한다.
샘플링된 데이터셋에서 전통적인 추천 모델과 비교하여 우수하거나 유사한 성능을 보이며, 전체 데이터셋에서 훈련된 모델과 비슷한 성능을 기록하였다.
Pop, BM25, LLMRank와 같은 튜닝 없는 기존 방법들은 만족스럽지 않은 성능을 나타내며, LLM의 일반 지식이 사용자 선호를 포착하는 데 한계를 보인다.

3.3 Further Model Analyses

3.3.1 Ablation Study

제안된 협업 필터링 접근법의 각 구성 요소의 효과를 검증하기 위한 절제 연구를 수행하였다.
1. 𝑤/𝑜 Autonomous Interaction : 실제 사용자 상호작용 기록을 제공하여 에이전트의 반응을 관찰함으로써 시뮬레이션된 에이전트와 실제 사용자 간의 불일치를 확인하였다.
2. 𝑤/𝑜 User Agent : 사용자 에이전트 최적화를 제거하고 단순히 과거 상호작용으로 사용자 표현을 나타내어 성능 저하를 확인하였다.
3. 𝑤/𝑜 Item Agent : 아이템 에이전트 최적화를 제거하여 성능 저하를 확인하고, 사용자와 아이템 간의 상호작용 관계를 캡처하는 데 있어 아이템 에이전트의 중요성을 강조한다.

3.3.2 Performance Comparison w.r.t. Position Bias and Popularity Bias

개인화된 에이전트를 시뮬레이션하는 능력을 평가하기 위해 위치 및 인기 편향의 영향을 조사하였다.
LLMRank는 인기와 위치 편향에 영향을 받는 반면, 제안된 접근법은 개인화된 선호에 기반하여 더 안정적인 성능을 보여준다.

3.3.3 Effectiveness of Collaborative Reflection

최적화 과정에서 에이전트와 실제 사용자 간의 정렬 변화를 평가하여 Collaborative Reflection의 효과를 확인하였다.
지속적인 최적화가 사용자 에이전트의 선호를 실제 사용자와 일치시키는 데 기여함을 보여준다.

3.4 Simulations on Other Types of Interactions

3.4.1 User-user Interaction Simulation

사용자 에이전트가 다른 사용자와 유사한 사회적 행동을 나타내는지 확인하기 위해 사용자 간 상호작용을 시뮬레이션하였다.
사용자가 긍정적 리뷰를 접했을 때 구매 의향이 증가하고 부정적 리뷰를 접했을 때 구매를 자제하는 경향을 보인다.

3.4.2 Item-item Interaction Simulation

콜드 스타트 문제를 완화하기 위해 새로운 아이템 에이전트와 인기 아이템 에이전트 간의 자율 상호작용을 탐색하였다.
새로운 아이템 에이전트가 사용자 선호를 추정하고 메모리를 조정하여 추천 성능을 향상시키는 과정을 보여준다.

3.4.3 Process of Preference Propagation

collaborative 최적화를 통해 선호 전파 과정을 자세히 설명한다.
사용자와 아이템 에이전트가 상호작용하여 서로의 선호를 전파하는 과정을 보여준다.

3.4.4 Collaborative Advertisements Creation

여러 LLM 간 협력이 광고 생성 결과를 개선할 수 있음을 탐구하였다.
다양한 광고 전문성을 가진 에이전트가 협력하여 더 매력적인 광고를 생성하는 과정이 나타난다.

5. Conclusion and Future Work

본 논문에서는 추천 시스템에서 사용자-아이템 상호작용을 시뮬레이션하기 위한 에이전트 기반 협업 필터링 접근법인 AgentCF를 제안하였다.

에이전트 : 사용자뿐만 아니라 아이템도 에이전트로 설정하여 LLM 기반 에이전트 간의 상호작용을 통해 two-sided 관계를 모델링한다.
collaborative 학습 접근법 : 사용자 및 아이템 에이전트를 함께 최적화하여 자율적인 상호작용을 수행하고, 그들의 결정과 실제 상호작용 기록 간의 불일치를 반영한다.
선호 전파 : 이 과정에서 사용자와 아이템 에이전트는 서로의 선호를 조정하고, 후속 상호작용에서 이 정보를 다른 에이전트에게 전파하여 협업 필터링 아이디어를 암묵적으로 모델링한다.
인간 유사 행동 : 시뮬레이션된 사용자 및 아이템 에이전트는 다양한 유형의 상호작용(사용자-아이템, 사용자-사용자, 아이템-아이템, 집단 상호작용)에서 인간과 유사한 행동을 보이며, AgentCF의 효과성을 입증한다.

향후 연구 방향

다양한 실제 시나리오 탐색 : 향후 연구에서는 더 많은 유형의 실제 시나리오와 그에 따른 상호작용을 탐구할 예정이다.
비인간 에이전트의 자율성 : AgentCF는 LLM 기반 에이전트를 통해 인간뿐만 아니라 비인간 객체도 시뮬레이션할 수 있는 작은 단계로, 비인간 객체에 자율성을 부여하고 모든 것을 연결하는 지능형 에이전트 생태계를 형성할 가능성을 지니고 있다. 이러한 주제는 향후 연구에서 다룰 것이다

LLM-powered Agents

최근 LLM 기반 에이전트는 추론 및 계획 능력 덕분에 AGI 개발의 잠재력을 보여주고 있다. memory와 reflection 모듈을 갖춘 에이전트들은 과거 경험을 저장하고 미래 행동에 대한 더 나은 결정을 내릴 수 있다.

Memory 모듈

Memory 모듈은 에이전트가 이전의 대화 내용이나 사용자와의 상호작용에서 얻은 정보를 저장하고 활용할 수 있도록 한다. 이를 통해 에이전트는 사용자의 선호, 과거 질문 및 답변, 대화의 맥락 등을 기억하여 보다 일관되고 개인화된 응답을 제공할 수 있다. Memory는 에이전트가 장기적인 대화 맥락을 유지하고, 사용자와의 관계를 발전시키는 데 중요한 역할을 한다.

Reflection 모듈

Reflection(반성) 모듈은 에이전트가 자신의 행동이나 응답을 평가하고, 이를 바탕으로 학습할 수 있도록 돕는다. 이 모듈은 에이전트가 과거의 상호작용에서 얻은 피드백을 분석하고, 어떤 응답이 효과적이었는지, 어떤 부분에서 개선이 필요한지를 반영한다. Reflection은 에이전트가 지속적으로 발전하고, 사용자와의 상호작용에서 더 나은 성과를 낼 수 있도록 하는 데 기여한다.

일상적인 상호작용을 시뮬레이션하기 위해 에이전트를 활용하는 여러 연구가 제안되었으며, 여기에는 작은 마을의 일상, 토론, 심지어 게임 플레이가 포함된다. 이러한 연구들은 LLM 기반 에이전트가 사용자-아이템 상호작용을 시뮬레이션하는 응용 가능성을 탐구하도록 영감을 준다.

1. 작은 마을의 일상

Generative Agents: Interactive Simulacra of Human Behavior (2023)

Generative Agents는 신뢰할 수 있는 인간 행동을 시뮬레이션하는 계산 소프트웨어 에이전트로, 이들은 일상적인 활동(예: 아침식사 준비, 출근 등)을 수행하고, 예술 활동을 하며, 의견을 형성하고 대화를 시작하는 등 인간과 유사한 행동을 한다.

Generative Agents에 LLM을 활용하는데, 자연어를 사용하여 에이전트의 경험에 대한 기록을 저장한다. 그리고 시간이 지남에 따라 이러한 기억을 더 높은 수준의 reflection으로 합성하고, 이를 동적으로 검색하여 행동을 계획한다. 이들은 The Sims에서 영감을 받은 인터랙티브 샌드박스 환경에 배치되어, 사용자가 자연어로 25명의 에이전트가 있는 소도시와 상호작용할 수 있게 한다.

평가 결과, 생성 에이전트들은 신뢰할 수 있는 개인 행동과 사회적 행동을 발휘한다. 예를 들어, 한 에이전트가 발렌타인 데이 파티를 열고 싶다는 단서로 시작해, 에이전트들이 자율적으로 초대장을 퍼뜨리고 새로운 친구를 사귀며, 파티에 함께 참석하기 위해 조율하는 모습을 보여준다.

2. 토론

Improving Factuality and Reasoning in Language Models through Multiagent Debate (2023)

이 연구에서는 여러 언어 모델 인스턴스가 각자의 응답과 추론 과정을 제안하고 논의하여 공통의 최종 답변에 도달하는 방법을 소개한다. 연구 결과, 이 접근 방식이 수학적 및 전략적 추론 능력을 크게 향상시키며, 생성된 콘텐츠의 사실적 유효성을 개선하고, 현대 모델들이 자주 발생시키는 오류와 환각을 줄인다는 것을 보여준다.

3. 게임 플레이

Voyager: An Open-Ended Embodied Agent with Large Language Models (2023)

이 논문에서는 최초로 LLM 기반으로 구현된 Lifelong Learning Agent(지속적인 학습 능력을 갖춘 에이전트)인 Voyager를 소개한다. Voyager는 Minecraft 세계를 지속적으로 탐험하며, 다양한 기술을 습득하고 새로운 발견을 하며, 인간의 개입 없이 작동한다. Voyager는 GPT-4와 블랙박스 쿼리를 통해 상호작용하며, 모델 파라미터의 미세 조정 없이 작업을 수행한다.

Blackbox Query

블랙박스 모델 : 내부 작동 방식이나 파라미터에 대한 접근 없이, 입력을 주면 출력만 얻는 시스템을 말한다. 쿼리 방식 : Voyager는 GPT-4에 특정 질문이나 요청(쿼리)을 보내고, 그에 대한 응답을 받아 이를 활용합니다. 이 과정에서 GPT-4의 내부 동작이나 구조는 고려하지 않으며, 모델이 제공하는 정보나 답변을 그대로 사용한다.

Language Model for Recommendation

추천을 위해 언어 모델을 활용하려는 여러 시도가 있었다. 구체적으로, 언어 모델이 사용자 과거 상호작용을 바탕으로 사용자 선호를 추론하도록 유도하는 연구가 있었다. 그러나 LLM의 보편적인 지식과 도메인 특정 사용자 행동 패턴 간의 간극 때문에 개인화된 추천을 제공하는 데 한계가 있을 수 있다.

이를 해결하기 위해 여러 연구는 LLM의 지식을 통합하여 추천 모델을 향상시키는 방법을 제안하고 있다. 일부 연구는 추천 데이터를 기반으로 LLM을 미세 조정하여 추천에 특화시키기도 하지만, 이는 시간이 많이 소요될 수 있다.

최근 연구자들은 추천 시스템에 에이전트를 통합하려고 시도하며, 추천을 촉진하거나 사용자 행동 시뮬레이션에 중점을 두고 있다.

그러나 이러한 연구들은 주로 사용자 행동에 초점을 맞추고 사용자-아이템 관계 모델링을 간과하는데, 이는 추천 시스템의 핵심이다. 이러한 방법들과 달리, 본 논문은 아이템을 에이전트로 간주하고 사용자와 아이템 에이전트가 two-sided 관계를 모델링할 수 있도록 에이전트 기반 협업 필터링 접근 방식을 제안한다.

1. InteRecAgent

Recommender AI Agent: Integrating Large Language Models for Interactive Recommendations (2023)

이 논문에서는 추천 모델과 LLM의 장점을 결합하여 다목적이고 interactive한 추천 시스템을 만드는 방법을 제안한다. InteRecAgent는 추천 모델과 LLM 간의 간극을 메우기 위해 LLM을 두뇌로, 추천 모델을 도구로 사용한다. InteRecAgent는 ID 기반 Matrix Factorization 모델과 같은 기존 추천 시스템이 LLM 통합을 통해 자연어 인터페이스를 갖춘 interactive 시스템으로 발전할 수 있게 한다.

(a) InteRecAgent의 파이프라인

(b) 메모리 모듈 : 이 모듈은 후보 메모리 버스, 장기 사용자 프로필, 단기 사용자 프로필로 구성되어 있다. 이를 통해 사용자의 행동과 선호도를 저장하고 관리한다.

(d) 계획 모듈 : Dynamic Demonstration(특정 작업이나 문제 해결 과정을 실시간으로 보여주는 방식)과 Reflection 전략을 포함하여, 추천 작업을 효율적으로 계획하고 조정하는 역할을 한다.

(e) RecLlama fine-tuning 데이터

2. RecSim

RecSim: A Configurable Simulation Platform for Recommender Systems (2019)

RecSim은 추천 시스템에서 강화학습을 사용하기 위한 시뮬레이션 환경을 구성할 수 있는 플랫폼이다. RecSim은 사용자와의 순차적 상호작용을 자연스럽게 지원하며, 사용자 행동 및 아이템 구조의 특정 측면을 반영하는 새로운 환경을 생성할 수 있다. (Google 연구)

3. CORE

Lending Interaction Wings to Recommender Systems with Conversational Agents (2023)

CORE는 대화형 에이전트(챗봇)를 추천 시스템에 통합하기 위한 오프라인 훈련 및 온라인 확인 시스템이다. 기존의 대화형 추천 접근 방식이 대화와 추천 부분을 강화 학습 프레임워크를 통해 결합하는 것과 달리, CORE는 unified uncertainty minimization framework(불확실성 최소화)를 통해 대화형 에이전트와 추천 시스템을 연결한다.

4. RecAgent

RecAgent: A Novel Simulation Paradigm for Recommender Systems (2023)

RecAgent는 LLM 기반 추천 시뮬레이터이다. 사용자 모듈의 가상 사용자는 추천 웹사이트(개인화된 콘텐츠나 제품을 추천하는 기능을 제공하는 웹 플랫폼)를 탐색하고, 다른 사용자와 소통하며, 소셜 미디어에 메시지를 전파할 수 있다. 추천 모듈은 사용자에게 검색 또는 추천 목록을 제공하며, 다양한 모델을 설계할 수 있다. 모든 사용자는 LLM을 기반으로 행동하며, 실제 세계처럼 자유롭게 진화할 수 있다.

5. RecMind

RecMind: Large Language Model Powered Agent For Recommendation (2023)

RecMind는 외부 지식을 활용하고 도구를 신중하게 계획하여 zero-shot 개인화 추천을 제공할 수 있는 LLM 기반 자율 추천 에이전트이다. Self-Inspiring 알고리즘은 계획 능력을 향상시키기 위해 제안된 알고리즘으로, LLM이 각 중간 단계에서 이전에 탐색한 모든 상태를 고려하여 다음 단계를 계획한다. 이 메커니즘은 추천을 위한 계획 과정에서 과거의 정보를 이해하고 활용하는 능력을 크게 향상시킨다.

RecMind : ChatGPT API를 기반으로 구축된다. Tools : Memory 구성 요소에서 지식을 검색하기 위한 다양한 API 호출을 지원한다. Planning : 사고 생성 역할을 한다.

[논문] Large Language Models as Zero-Shot Conversational Recommenders

Wed, 05 Mar 2025 02:14:07 GMT

📄 Paper

Large Language Models as Zero-Shot Conversational Recommenders [arxiv]

Zhankui He ACM CIKM 23

📝 Key Point

zero-shot 대화 추천 시스템 : LLMs을 zero-shot CRS로 활용하여 기존의 fine-tuning된 CRS 모델을 초월하는 성과를 보였다.
repetition shortcut 문제 : 기존 CRS 평가에서 반복 아이템을 강조하는 평가 방식의 문제를 지적하고, 신뢰성 있는 모델 설계를 위한 기준 마련의 필요성을 제기했다.
새로운 데이터셋 : Reddit-Movie라는 새로 구축한 데이터셋이 CRS 연구에 다양성과 현실성을 제공하였다.
LLM의 Content/Context 지식 : LLM이 fine-tuning 없이도 우수한 Content/Context 지식을 바탕으로 CRS 작업에 효과적임을 입증하였다.

Abstract

LLM을 사용한 zero-shot 대화 추천 작업을 제안한다.

*데이터 *
- 인기 있는 토론 웹사이트에서 추천 관련 대화 데이터를 수집하였다.
- 이는 현재까지 가장 큰 공개 실제 대화 추천 데이터셋이다.
평가
- 새로운 데이터셋과 기존 두 개의 대화 추천 데이터셋에서 실험을 수행하였다.
- LLM이 fine-tuning 없이도 기존 fine-tuning된 대화 추천 모델보다 뛰어난 성능을 보였다.
분석
- LLM의 대화 추천 성능을 설명하기 위한 다양한 probing 작업을 제안한다.
- LLM의 행동과 데이터셋의 특성을 분석하여 모델의 효과성 및 한계에 대한 포괄적인 이해를 제공한다.
- 향후 대화 추천 시스템 설계 방향을 제안한다.

Figure

LLM을 zero-shot 대화 추천 시스템으로 활용하는 방법을 제시한다.
프롬프트 전략
- $T$ : 작업 설명 , $F$ : 형식 요구사항 , $S$ : 대화 맥락 , $\mathcal{F}$ : LLM , $\Phi$ : processor
- 작업 설명, 형식 요구사항, 대화 맥락을 조합하여 LLM에 입력하고, 생성된 추천 결과를 후처리하여 순위가 매겨진 아이템 리스트로 변환한다.

1. Introduction

대화 추천 시스템(CRS)의 목적
- CRS는 사용자 선호를 파악하고 개인화된 추천을 제공하기 위해 대화형 상호작용을 활용한다.
- CRS는 사용자 행동을 이해하고 인간 같은 응답을 제공할 수 있는 장점이 있다.
구성 요소
- CRS는 자연어 응답을 생성하는 생성기와 아이템 순위를 매기는 추천기로 구성된다.
대형 언어 모델의 발전
- 최근 LLM의 발전이 주목받고 있으며, CRS에서의 활용 가능성이 탐구되고 있다.
- 현재 연구는 주로 전통적인 추천 설정에서 LLM의 성능을 평가하고 있다.
연구 기여
- 데이터 : Reddit-Movie라는 대규모 대화 추천 데이터셋을 구축하였으며, 이는 634,000개 이상의 대화를 포함한다.
- 평가 : LLM의 추천 성능을 재평가하여 기존 평가의 문제점을 지적하였다.
- 분석 : LLM의 성능 원인을 탐구하고, 프로빙 작업을 통해 한계를 분석하였다.
주요 발견
- 반복 아이템 제거 후 CRS 능력을 재평가해야 한다.
- LLM은 기존 모델보다 향상된 성능을 보인다.
- LLM은 주로 Content/Context 지식을 활용하여 추천을 한다.
- CRS 데이터셋은 LLM에 더 적합하다.
- LLM은 인기 편향 및 지리적 민감성과 같은 한계가 있다.

2. LLMS AS ZERO-SHOT CRS

2.1 Task Formation

대화 표현
- 사용자 집합 $U$, 아이템 집합 $I$, 어휘 $V$가 주어질 때, 대화는 $C = (u_t, s_t, I_t)_{t=1}^T$로 표현된다.
- $t$번째 대화 턴에서, 발화자 $u_t \in U$가 발화 $s_t = (w_i)_{i=1}^m$를 생성하며, 이는 어휘 $V$의 단어 시퀀스이다.
- 발화 $s_t$는 언급된 아이템 집합 $I_t \subset I$를 포함하며, 아이템이 언급되지 않을 경우 빈 집합이 될 수 있다.
대화자 역할
- 일반적으로 대화 $C$에는 두 사용자가 있으며, 각각 탐색자와 추천자의 역할을 수행한다.
- ex) Figure 1의 두 번째 대화 턴에서 $t = 2$, $u_t$는 [System], $s_t$는 "You would love Terminator!"이며, $I_2$는 영화 Terminator를 포함하는 집합이다.
추천 목표
- CRS의 추천자 구성 요소는 다음 목표를 최적화하도록 설계된다.
- $k$번째 대화 턴에서, 추천자 $u_k$는 대화 맥락 $(u_t, s_t, I_t)_{t=1}^{k-1}$을 입력으로 받아, $I_k$의 실제 아이템과 가장 잘 일치하는 순위가 매겨진 아이템 목록 $\hat{I}_k$를 생성한다.

2.2 Framework

프롬프트 설정
- LLM을 zero-shot 대화 recommender로 활용하는 것이 목표이다.
- fine-tuning 없이 작업 설명 템플릿 $T$, 형식 요구사항 $F$, 대화 맥락 $S$를 사용하여 LLM을 프롬프트한다.
- $$\hat{I}_k = \Phi(\mathcal{F}(T, F, S))$$
모델
- zero-shot 프롬프트 능력을 가진 여러 인기 LLM을 두 그룹으로 나누어 고려한다.
- 사전 훈련된 모델
  - GPT-3.5-turbo / GPT-4 : 복잡한 작업을 해결하는 능력이 있지만 소스가 비공개이다.
- 오픈 소스 모델
  - BAIZE / Vicuna : LLAMA-13B 기반으로 fine-tuning된 대표적인 오픈 소스 LLM이다.
processing
- LLM의 모델 가중치나 출력 로짓을 평가하지 않으며, 후처리기 $\Phi$ (e.g. fuzzy matching)를 적용하여 자연어로 된 추천 목록을 순위가 매겨진 아이템 ID 목록 $\hat{I}_k$로 변환한다.
- 아이템 ID 대신 아이템 제목을 생성하는 방식은 생성적 검색(generative retrieval) 패러다임으로 불린다.

3. DATASET

필요성

대화 추천 모델의 평가를 위해서는 다양한 상호작용과 실제 대화를 포함하는 대규모 데이터셋이 필요하다.
기존의 크라우드 소싱 데이터셋은 현실적인 대화 역동성을 충분히 반영하지 못한다.

크라우드 소싱 (crowd-sourced)

특정 작업이나 프로젝트를 수행하기 위해 대중의 지식, 기술, 자원 등을 활용하는 방법

참여자 : 다양한 사람들이 특정 작업을 수행하기 위해 고용되거나 자발적으로 참여한다.
제한된 현실성 : 크라우드 작업자는 특정한 선호나 관심이 없을 수 있어, 그들의 응답이 실제 사용자 대화와 다를 수 있다.
예시 데이터셋 : 논문에서는 ReDIAL과 INSPIRED와 같은 기존의 크라우드 소싱 데이터셋을 언급하며, 이러한 데이터셋이 크라우드 소싱의 한 예로 제시된다.

Reddit-Movie 데이터셋

Reddit-Movie는 현재까지 가장 큰 대화 영화 추천 데이터셋으로, 자연 발생적인 영화 추천 대화를 포함한다.
본 연구에서는 ReDIAL과 INSPIRED 데이터셋과 함께 Reddit 데이터셋을 사용하여 모델 평가를 수행한다.

데이터셋 구축

2012년 1월부터 2022년 12월까지의 Reddit 게시물에서 영화 추천 관련 게시물을 추출하여 데이터셋을 구축하였다.
최신 9,000개의 대화를 테스트 세트로 사용하고, 나머지 76,000개의 대화는 훈련 및 검증에 활용한다.

논의

Reddit-Movie 데이터셋은 634,392개의 대화를 포함하며, 51,203개의 영화를 다룬다.
ReDIAL과 INSPIRED에 비해 multi-turn 대화가 적지만, 더 복잡하고 상세한 사용자 선호를 포함하여 다양하고 풍부한 논의를 제공한다.

4. EVALUATION

4.1 Evaluation Setup

반복 아이템 vs. 새로운 아이템
- 대화에서 추천된 실제 아이템을 식별하는 것은 도전적인 주제이다. 일반적인 평가 설정에서는 모든 아이템이 실제 추천 아이템으로 간주된다.
- 본 연구에서는 아이템을 반복 아이템과 새로운 아이템으로 구분한다. 반복 아이템은 이전 대화 턴에 등장한 아이템이고, 새로운 아이템은 이전 턴에서 언급되지 않은 아이템이다.
평가 프로토콜
- ReDIAL, INSPIRED, Reddit 데이터셋에서 여러 대표적인 CRS 모델과 LLM의 추천 능력을 평가한다. 기준 모델은 Recall@K를 사용하여 예측 성능을 보고한다.
비교 모델
- ReDIAL : ReDIAL 데이터셋과 함께 출시된 모델로, 오토인코더 기반의 추천 시스템이다.
- KBRD : DBPedia를 활용하여 아이템이나 엔티티의 의미적 지식을 강화하는 모델이다.
- KGSF : 두 개의 지식 그래프를 통합하여 단어와 엔티티의 표현을 향상시키는 모델이다. 상호 정보 최대화(Mutual Information Maximization) 방법을 사용하여 두 지식 그래프의 의미 공간을 정렬한다.
- UniCRS : 사전 학습된 언어 모델인 DialoGPT를 사용하여 추천 및 대화 생성 작업을 수행하는 모델이다. 프롬프트 튜닝을 통해 대화의 맥락을 이해하고, 추천 품질을 개선한다.

4.2 Repeated Items Can Be Shortcuts

현재 대화 추천 시스템에 대한 평가는 반복 아이템과 새로운 아이템을 구분하지 않는다. 이로 인해 반복 아이템을 언급하는 시스템이 유리하게 평가된다. 예를 들어, 대화 이력에서 본 아이템을 항상 복사하는 단순 기준 모델이 대부분의 이전 모델보다 더 나은 성능을 보인다.
새로운 아이템 추천에만 집중할 경우, 모델의 HIT@1 성능이 평균 60% 이상 감소한다. 반복 아이템의 비율이 높은 경우(예: INSPIRED의 15% 이상)를 고려할 때, 반복 아이템을 제거하고 CRS 모델을 재평가하는 것이 추천 능력을 더 잘 이해하는 데 유리하다.

4.3 LLMs Performance

발견 1 : LLM은 zero-shot 설정에서 fine-tuning된 CRS 모델보다 우수한 성능을 보인다. 새로운 아이템 추천을 위해 기존 CRS 모델을 재훈련한 결과, LLM이 모든 데이터셋에서 가장 좋은 성능을 보인다.
발견 2 : GPT 기반 모델이 다른 오픈 소스 LLM보다 뛰어난 성능을 나타낸다. GPT-4가 GPT-3.5-t보다 일반적으로 더 좋은 성능을 보이며, 이는 더 큰 파라미터 크기가 영화 이름과 사용자 선호 간의 상관관계를 더 잘 유지할 수 있게 해주기 때문이다.
발견 3 : LLM은 허용된 아이템 세트 외의 아이템을 생성할 수 있으며, 이러한 아이템을 제거하면 추천 성능이 향상된다. GPT 기반 모델의 약 95%의 추천은 IMDB에서 일치하는 것으로 확인되고, 환각된 추천이 거의 없었다. $\Phi_0$ : 생성된 모든 아이템 제목 $\Phi_1$ : 데이터셋에 있는 아이템 제목만 선별 (환각 추천 아이템 제외)

5. DETAILED ANALYSIS

5.1 Knowledge in LLMs

실험 설정 : LLM이 CRS에서 사용할 수 있는 두 가지 지식 유형을 정의하고 실험을 통해 이들의 효과를 분석한다.
- Collaborative 지식 : 사용자가 선호하는 아이템 간의 유사성을 기반으로 추천하는 능력이다. "A를 좋아하는 사용자는 B도 좋아할 가능성이 높다"는 원칙에 따라 추천한다.
- Content/Context 지식 : 추천된 아이템의 콘텐츠나 대화 맥락 정보를 기반으로 추천하는 능력이다. 이는 대화에서 언급된 장르, 감독 이름, 그리고 대화의 다른 내용들을 포함한다.
발견 4 : LLM은 주로 Content/Context 지식을 활용하여 추천하며, 반복 아이템만 사용하는 경우 성능이 평균 60% 이상 감소한다. 반면, 아이템을 제거하거나 랜덤 샘플링으로 대체할 경우 성능 감소는 10% 미만이다. 이는 LLM이 대화의 내용과 맥락 정보를 더 중요하게 사용하고 있음을 나타낸다.
발견 5 : GPT 기반 LLM이 기존의 대화 추천 모델보다 더 나은 Content/Context 지식을 보여준다. 모든 데이터셋에서 GPT 기반 LLM이 사용자 선호를 이해하고 정확한 아이템 제목을 생성하는 데 뛰어난 성능을 보인다. 이로 인해 ItemRemoved 설정에서도 기존 CRS 모델보다 더 정확한 추천을 제공한다.
발견 6 : LLM의 Collaborative 지식은 기존 CRS 모델에 비해 약하다. ItemOnly 설정에서 LLM은 ReDIAL 및 INSPIRED 데이터셋에서 30% 이상 성능이 떨어진다. 이는 LLM이 일반적인 데이터셋에서 훈련되었기 때문에 특정 데이터셋의 상호작용 패턴과 일치하지 않을 수 있음을 시사한다. 그러나 Reddit 데이터셋에서는 LLM이 기준 모델을 초과하는 성능을 나타내며, 이는 데이터셋의 특성과 관련이 깊다.

5.2 Information from CRS Data

발견 7 : Reddit 데이터셋은 다른 두 CRS 데이터셋보다 더 많은 Content/Context 정보를 포함하고 있다. 이는 LLM이 Reddit 데이터셋에서 더 높은 성능을 보이는 이유로 작용한다.
발견 8 : 현재 모델로는 Collaborative 정보만으로 만족스러운 추천을 제공하기 어렵다는 점이 드러난다. ItemOnly 설정에서의 성능이 Original 설정과 비교하여 큰 차이를 보이며, 이는 Collaborative 정보의 한계점을 나타낸다. 기존 모델들이 Collaborative 정보만으로는 추천의 품질을 보장할 수 없음을 보여준다.
발견 9 : Collaborative 정보는 데이터셋이나 플랫폼에 따라 달라질 수 있으며, 동일한 아이템이더라도 특정 데이터셋에서의 성능 차이가 존재한다. 이는 LLM이 특정 데이터셋에서 Collaborative 정보를 잘 활용하지 못할 수 있음을 시사한다.

5.3 Limitations of LLMs as Zero-shot CRS

발견 10 : LLM 추천은 인기 아이템에 편향되는 경향이 있다. 예를 들어, ReDIAL 데이터셋에서 "Avengers: Infinity War"와 같은 인기 영화는 실제 데이터셋에서의 비율보다 LLM 추천에서 더 자주 등장한다. 이는 LLM이 훈련 과정에서 학습한 데이터의 편향을 반영할 수 있다.
발견 11 : LLM의 추천 성능은 지역에 따라 민감하게 변한다. 영어권 영화에 대한 추천 성능이 더 높으며, 이는 훈련 데이터의 편향 때문일 수 있다. LLM이 특정 문화나 지역에 대한 추천에서 효과적이지 않을 수 있으며, 이는 다양한 문화와 지역에 대한 분석과 평가의 필요성을 강조한다.

7. CONCLUSION AND DISCUSSION

연구 목적 : LLM을 zero-shot 대화 추천 시스템(CRS)으로 연구하고, 이전 CRS 평가에서의 repetition shortcut 문제를 다루었다.
주요 발견 : LLM은 모든 fine-tuning된 기존 CRS 모델을 초월하는 성과를 보였으며, LLM의 작동 메커니즘과 CRS 작업의 특성을 분석하였다.
데이터셋 : 두 개의 공개 데이터셋과 새롭게 생성한 영화 추천 데이터셋을 사용하여, CRS 연구에 더 다양하고 현실적인 대화를 제공하였다.
LLM의 잠재력 : LLM은 fine-tuning 없이도 뛰어난 성능을 보이며, CRS 작업에 효과적이다. 오픈 소스 LLM의 성과는 CRS 성능 향상을 위한 튜닝 및 Collaborative Filtering의 가능성을 제시한다.
CRS 재평가 필요성 : CRS 모델의 체계적인 재평가와 다양한 출처에서의 새로운 데이터셋 구축이 필요하다. LLM의 Content/Context 지식의 중요성을 강조하며, CRS 작업과 전통적인 추천 시스템 간의 상호 연결성을 탐구할 필요성을 제안한다.

Conversational Recommendation

대화형 추천 시스템은 대화를 통해 사용자 선호도를 이해하고 개인화된 추천을 제공하는 것을 목표로 한다.

1. 전통적인 CRS

1-1. Template-based CRS

템플릿 기반 CRS는 미리 정의된 템플릿을 사용하여 사용자와의 대화를 통해 추천을 제공한다. 고정된 구조의 대화 패턴을 기반으로 작동하며, 사용자의 요구에 맞춘 추천을 제공하기 위해 템플릿을 활용한다.

정형화된 대화 흐름 : 템플릿을 사용하여 대화의 흐름을 정형화하고, 사용자가 특정 질문이나 요청을 할 때 일관된 방식으로 응답한다.
사전 정의된 질문 및 응답 : 추천 시스템은 특정 상황에 맞는 질문과 응답을 미리 정의하여 사용자의 입력에 따라 적절한 템플릿을 선택하여 대화를 진행한다.
제한된 유연성 : 템플릿 기반 시스템은 유연성이 떨어질 수 있으며, 사용자의 다양한 요청에 완벽하게 대응하지 못할 수 있다.
쉬운 구현 : 비교적 간단하게 구현할 수 있으며, 특정 도메인에 맞춰 빠르게 설정할 수 있다.

1-2. Critiquing-based CRS

비평 기반 CRS는 사용자와의 상호작용을 통해 개인화된 추천을 제공한다. 사용자가 제공하는 피드백이나 비판을 기반으로 추천 결과를 조정하고 개선하는 방식으로 작동한다.

사용자 피드백 : 사용자가 추천된 항목에 대해 긍정적 또는 부정적인 피드백을 제공할 수 있으며, 이 피드백은 향후 추천에 반영된다.
대화형 상호작용 : 사용자는 시스템과 대화를 통해 자신의 선호도를 명확히 하고, 특정 항목에 대한 선호도를 표현할 수 있다.
추천 조정 : 사용자의 비판이나 의견에 따라 추천 알고리즘이 조정되어 더 나은 개인화된 추천을 제공하게 된다.
적응성 : 시스템은 지속적으로 사용자의 피드백을 학습하여 시간이 지남에 따라 추천 품질을 향상시킨다.

2. Deep CRS

Deep CRS는 딥러닝 기술을 활용하여 사용자와의 대화를 통해 개인화된 추천을 제공한다. 자연어 처리와 심층 신경망을 활용하여 사용자와의 상호작용을 보다 효율적으로 처리하고, 복잡한 패턴을 학습하여 추천 품질을 향상시킨다.

딥러닝 기반 모델 : 딥러닝 아키텍처(ex. RNN, LSTM, Transformer 등)를 사용하여 대화의 맥락을 이해하고, 사용자 선호를 모델링한다.
자연어 처리 : 자연어 이해(NLU)와 자연어 생성(NLG) 기술을 통해 사용자와의 대화를 자연스럽고 효과적으로 진행한다.
상황 인식 : 사용자의 요청이나 질문을 이해하고, 그에 맞춰 적절한 추천을 제공하기 위해 대화의 맥락을 파악한다.
개인화된 추천 : 사용자 데이터와 대화의 내용을 바탕으로 개인화된 추천을 제공하며, 사용자 피드백을 통해 지속적으로 학습하고 개선할 수 있다.
다양한 작업 수행 : 질문 응답, 정보 검색, 아이템 추천 등 다양한 작업을 수행할 수 있는 능력을 갖추고 있다.

3. Additional Information을 활용한 CRS

Additional Information을 활용한 CRS는 협업 필터링(CF) 외의 다양한 정보를 활용하여 추천 성능을 향상시킨다.

3-1. Knowledge-enhanced Models

외부 지식 기반(ex. 위키피디아, 도메인 특정 데이터베이스 등)을 활용하여 추천 품질을 향상시킨다.

사용자의 요청사항이나 아이템에 대한 추가적인 배경 지식을 제공하여 보다 정확한 추천을 가능하게 한다.
예를 들어, 특정 영화에 대한 정보(장르, 감독, 출연 배우 등)를 활용하여 사용자의 관심사에 맞는 영화를 추천할 수 있다.

3-2. Review-aware Models

사용자 리뷰와 평점을 고려하여 추천을 제공한다.

리뷰의 감정 분석이나 키워드 추출을 통해 사용자 선호도를 파악하고, 이를 추천 알고리즘에 통합한다.
예를 들어, 긍정적인 리뷰가 많은 아이템이나 특정 키워드가 자주 언급되는 아이템을 우선적으로 추천할 수 있다.

3-3. Session/Sequence-based Models

사용자의 세션 정보나 이전 상호작용의 순서를 고려하여 추천을 제공한다.

사용자의 행동 패턴을 분석하여 다음에 어떤 아이템을 추천할지 결정한다.
예를 들어, 사용자가 특정 카테고리의 아이템을 연속적으로 조회하는 경우, 그와 관련된 아이템을 추천할 수 있다.

4. LLM 기반 CRS

4-1. UniCRS

Towards Unified Conversational Recommender Systems via Knowledge-Enhanced Prompt Learning (2022)

UniCRS 모델은 대화형 추천 시스템을 위한 통합 모델로, 추천과 대화의 두 가지 작업을 하나의 접근 방식으로 통합하여 처리한다. 이 모델은 지식 강화 프롬프트 학습(Knowledge-Enhanced Prompt Learning)을 기반으로 하여, 사전 학습된 언어 모델(PLM)인 DialoGPT를 활용하여 두 작업을 효과적으로 수행할 수 있도록 설계되었다.

UniCRS 모델은 대화형 추천 시스템의 효율성을 높이고, 다양한 작업을 통합한다. 이 모델은 대화와 추천의 경계를 허물고 새로운 형태의 서비스 제공을 위한 기초를 마련하고 있다.

먼저, 단어와 엔티티의 의미를 융합하기 위해 사전 학습을 수행한다. 사전 학습된 언어 모델(PLM)을 사용하여 응답 템플릿을 생성하고, 이 템플릿을 추천을 위한 프롬프트의 일부로 사용한다. 마지막으로, 추천된 아이템이 템플릿에 채워져 완전한 응답이 된다.

Knowledge-Enhanced Prompt Learning

프롬프트 설계
- 융합된 지식 표현 : 사전 훈련된 의미 융합 모듈에서 생성된 지식 표현을 포함한다.
- 작업별 소프트 토큰 : 각 하위 작업에 맞는 소프트 토큰을 사용하여 프롬프트를 구성한다.
- 대화 맥락 : 대화의 맥락 정보를 제공하여 모델이 더 잘 적응할 수 있도록 한다.
응답 템플릿 : 대화 하위 작업에서 생성된 응답 템플릿을 추천 하위 작업의 중요한 부분으로 포함하여 두 하위 작업 간의 정보 상호작용을 강화한다.

RGCN (Relational Graph Convolutional Network)

heterogeneous graph에 사용할 수 있는 GNN 모델

RGCN은 관계에 따라 다른 가중치를 적용하여 노드의 이웃 정보를 집계하고, 노드의 표현을 업데이트한다. 즉, 각 관계 유형에 대해 별도의 합성곱 연산을 수행하며, 이를 통해 관계 정보를 더욱 세밀하게 반영한다.
RGCN은 추천 시스템, 지식 그래프 완성, 소셜 네트워크 분석 등 다양한 분야에서 활용된다. 특히, 관계가 중요한 데이터셋에서 강력한 성능을 발휘한다.

4-2. RecLLM

Leveraging Large Language Models in Conversational Recommender Systems (2023)

RecLLM은 LLM을 활용하여 사용자와의 대화를 통해 추천을 제공하는 데 중점을 두고 있다. 이는 사용자의 요구와 선호를 더 잘 이해하고 반영할 수 있도록 한다. 또한, RecLLM은 LLM의 잠재력을 활용하여 추천 시스템의 효율성과 개인화를 향상시킨다.

(1) Dialogue Manager : 대화 관리 모듈은 LLM을 사용하여 사용자와 대화하고, 맥락을 추적하며, 추천 엔진에 요청을 제출하는 등의 시스템 호출을 통합된 언어 모델링 작업으로 수행한다.

(2) Recommendation Engine : LLM 기반 CRS 내에서 대규모 아이템 코퍼스에 대한 효율적인 검색을 위한 다양한 솔루션이 제시된다.

(3) Ranker : 랭커 모듈은 LLM을 사용하여 대화의 맥락에서 추출된 선호도를 아이템 메타데이터와 매칭하고, 사용자에게 표시될 추천 목록을 생성한다. 또한, LLM은 사용자에게 제공되는 추천에 대한 설명을 함께 생성한다.

(4) User Profile : 해석 가능한 자연어 사용자 프로필이 시스템 LLM에 의해 사용되어 세션 수준의 맥락을 조절하고 개인화를 증가시킨다.

(5) User Simulator : LLM 기반 사용자 시뮬레이터는 CRS에 통합되어 모델을 튜닝하기 위한 합성 대화를 생성할 수 있다. 사용자 시뮬레이터는 실제 사용자와의 상호작용을 모사하여 합성 대화를 생성함으로써, 모델이 다양한 대화 상황을 학습할 수 있도록 돕는다.

4-3. iEvaLM

Rethinking the Evaluation for Conversational Recommendation in the Era of Large Language Models (2023)

iEvaLM 모델은 대화형 추천 시스템의 평가 방식을 재고하는 데 중점을 둔 접근 방식이다. 이 모델은 LLM 기반 사용자 시뮬레이터를 활용하여 상호작용 평가를 수행한다.

기존 대화형 추천 시스템의 평가 방식은 인간 주석자가 생성한 정답 항목과의 일치를 과도하게 강조하는 경향이 있다. iEvaLM 모델은 이러한 평가 방식을 혁신적으로 변화시키는 접근 방식으로, 사용자와의 상호작용을 중시하여 보다 실질적인 평가를 가능하게 한다.

Free-form Chit-chat : 자유로운 대화 형식으로, 사용자가 자연스럽게 대화할 수 있는 환경을 제공한다. 이 방식은 사용자가 특정 주제에 대해 질문하거나 의견을 표현할 수 있도록 하여, 보다 인간적인 상호작용을 가능하게 한다.
- 사용자의 다양한 질문과 반응을 수용할 수 있는 유연성을 제공한다.
- 대화의 맥락을 이해하고, 적절한 응답을 생성하는 데 중점을 둔다.
Attribute-based Question Answering : 특정 속성이나 특성에 기반하여 질문에 답하는 방식이다. 사용자가 관심 있는 특정 속성에 대해 질문하면, 시스템이 그에 맞는 정보를 제공하는 형태이다.
- 사용자가 원하는 정보나 추천을 보다 구체적으로 요청할 수 있도록 한다.
- 이는 추천의 정확성을 높이고, 사용자의 요구를 더 잘 충족시킬 수 있도록 한다.

Large Language Models

LLM의 일반화 능력 : LLM은 처음보는 작업과 도메인에 강력한 일반화 능력을 보여준다.

LLM의 매개변수 크기 확장 : 기존 연구들은 언어 모델의 성능과 다운스트림 작업에서의 샘플 효율성은 매개변수 크기를 증가시킴으로써 개선될 수 있음을 밝혀냈다.

Instruction Tuning : 언어 모델은 instruction 튜닝을 통해 처음보는 다양한 작업에서 더욱 일반화될 수 있다.

Downstream Task : 많은 연구들이 질문 응답, 수치 추론, 코드 생성, 상식 추론 등 다양한 다운스트림 작업에 대형 언어 모델을 성공적으로 배포하고 있다.

Sample Efficiency on Downstream Tasks

Downstream task는 모델이 학습한 후, 그 모델을 사용하여 수행하는 실제 응용 작업을 의미한다. 예를 들어, LLM 모델이 학습된 후, 그 모델을 사용하여 질문 응답, 텍스트 요약, 감정 분석 등과 같은 구체적인 작업을 수행하는 것을 말한다. Sample Efficiency on Downstream Tasks는 주어진 데이터 샘플을 얼마나 효과적으로 활용하여 모델의 성능을 향상시킬 수 있는지를 의미한다. 즉, 적은 양의 학습 데이터를 사용하더라도 높은 성능을 달성할 수 있는 능력을 나타낸다.

LLM 기반 추천

LLM에서 사용되는 아키텍처 조정 : M6-Rec, P5
기존 LLM을 추천에 재사용 : GPT4Rec, ChatGPT 추천, GeneRec

1. M6-Rec

M6 Rec: Generative Pretrained Language Models are Open-Ended Recommender Systems (2022)

Alibaba의 LLM 모델인 M6를 활용한 추천 시스템

M6 모델은 사용자 행동 데이터를 텍스트로 표현하고, 작업을 언어 이해/생성으로 변환하여 하위 작업에 활용할 수 있는 범용 모델이다. ex) "A male user in Beijing, who clicked product X last night and product Y this noon, was recommended product Z and did not click it."
M6-Rec 모델은 검색, 순위 매기기, 제로샷 추천, 설명 생성, 개인화된 콘텐츠 생성, 대화형 추천 등의 다양한 작업에서 그 유연성을 입증했다.

2. P5

Recommendation as Language Processing (RLP): A Unified Pretrain, Personalized Prompt & Predict Paradigm (P5) (2022)

P5 : Pretrain, Personalized Prompt, and Predict Paradigm

다양한 추천 작업을 통합할 수 있는 P5라는 유연한 text-to-text 패러다임을 제안한다. 기존의 추천 시스템에서는 작업별로 특화된 아키텍처와 훈련 목표가 필요했지만, P5는 모든 데이터를 자연어 시퀀스로 변환하여 공통 형식으로 처리한다.

P5는 개인화된 프롬프트를 통해 적응적으로 예측을 수행할 수 있어, zero-shot 또는 few-shot 방식으로 예측할 수 있으며, 광범위한 fine-tuning의 필요성을 크게 줄인다.

3. GPT4Rec

GPT4Rec: A Generative Framework for Personalized Recommendation and User Interests Interpretation (2023)

GPT4Rec은 사용자의 히스토리에 있는 아이템 제목을 바탕으로 가상의 "검색 쿼리"를 생성한 후, 이 쿼리를 검색하여 추천 아이템을 찾는 방식으로 설계되었다. 이 프레임워크는 사용자와 아이템의 임베딩을 언어 공간에서 학습하여, 다양성과 세분성(granularity) 관점에서 사용자 관심사를 잘 포착할 수 있도록 한다. 특히, Beam Search를 활용한 다중 쿼리 생성 기법을 통해 추천의 정확성과 다양성을 높이고, 콜드 스타트 아이템 추천을 위한 해석 가능한 user interests representation을 제공한다.

Beam Search

Beam Search는 최적의 해를 찾기 위해 사용되는 탐색 알고리즘이다. 주로 자연어 처리 분야에서 시퀀스 생성 문제를 해결하는 데 사용된다. 이 알고리즘은 최적의 한가지 경로만 탐색하거나 가능한 모든 경로를 탐색하는 대신, 각 단계에서 가장 유망한 몇 개의 경로만을 유지하여 다양성과 효율성을 높인다.

BM25

BM25는 정보 검색에서 문서의 관련성을 평가하는 데 사용되는 알고리즘이다. BM25는 TF-IDF 계열의 검색 알고리즘 중 하나로, 주어진 쿼리에 대해 문서와의 연관성을 점수화하여 랭킹을 매긴다. BM25는 전통적인 TF-IDF 방법을 개선하여 문서 길이와 평균 문서 길이를 고려하여 더 정확한 관련성 점수를 제공한다.

4. ChatGPT 추천

Is ChatGPT a Good Recommender? A Preliminary Study (2023)

ChatGPT를 추천 모델로 활용하여 추천 분야에서의 가능성을 탐구한다. ChatGPT의 지식을 추천 시나리오에 적용하여 높은 일반화 능력을 기대한다.

연구에서는 다섯 가지 추천 시나리오(평점 예측, 순차 추천, 직접 추천, 설명 생성, 리뷰 요약)에 대해 ChatGPT의 성능을 평가하기 위해 다양한 프롬프트를 설계했다. ChatGPT를 fine-tuning 없이 프롬프트만을 사용하여 추천 작업을 자연어 작업으로 변환했다. 또한, few-shot 프롬프팅을 통해 사용자 잠재 관심 정보를 주입하여 ChatGPT가 사용자 요구와 관심을 더 잘 이해하도록 했다.

5. GeneRec

Generative Recommendation: Towards Next-generation Recommender Paradigm (2023)

GeneRec은 생성 AI를 활용하여 개인화된 콘텐츠를 생성하고, 사용자 지침을 통합하여 콘텐츠 생성을 안내한다. 이를 위해 사용자의 지침과 피드백을 처리하여 생성 지침을 출력하는 Instructor를 사용한다. 그 후, AI editor와 AI creator를 통해 기존 아이템을 재구성하고 새로운 아이템을 생성한다.

[논문] Alleviating the Long-Tail Problem in Conversational Recommender Systems

Fri, 28 Feb 2025 09:08:46 GMT

📄 Paper

Alleviating the Long-Tail Problem in Conversational Recommender Systems [arxiv]

Zhipeng Zhao ACM RecSys 23

📝 Key Point

LOT-CRS 프레임워크 제안 : 대화형 추천 시스템(CRS)을 위한 long-tail 추천 향상을 목표로 하는 새로운 프레임워크를 제안한다.
균형 잡힌 데이터셋 시뮬레이션 : 공개적으로 수집된 아이템 속성을 활용하여 데이터 부족 문제를 해결하기 위해 균형 잡힌 CRS 데이터셋을 생성한다.
사전 학습 과제 설계 : PLM(Pre-trained Language Models)을 기반으로 하여, 대화 맥락 이해를 향상시키기 위해 두 가지 사전 학습 과제(Domain-Adaptive Masked Prediction & Contrastive Contexts Alignment)를 설계했다.
검색 보강 학습 및 라벨 스무딩 : 시뮬레이션된 데이터셋을 활용하여 long-tail 아이템 추천 성능을 개선하기 위해 검색 보강 학습과 라벨 스무딩 전략을 적용했다.

Abstract

연구 목적 : 대화형 추천 시스템(CRS)의 long-tail 문제를 완화하고 추천 성능을 향상시킨다.

문제점 : 기존 CRS 데이터셋은 long-tail 항목이 거의 언급되지 않아 추천 항목의 다양성이 줄어들고, 사용자가 쉽게 지루해진다.

제안 방법 : LOT-CRS라는 새로운 프레임워크를 통해 균형 잡힌 CRS 데이터셋을 시뮬레이션하고 활용했다.

pre-training : long-tail 아이템에 대해 시뮬레이션된 대화 이해를 향상시키기 위해 두 개의 사전 학습을 설계했다.

fine-tuning : 레이블 스무딩 전략을 적용한 검색 보강 미세 조정을 통해 long-tail 아이템의 추천 성능을 개선했다.

실험 결과 : 두 개의 공개 CRS 데이터셋을 통해 제안된 방법의 효과성과 확장성을 입증하였으며, 특히 long-tail 추천 성능이 향상되었다.

Figure

데이터 시뮬레이션 파이프라인

웹사이트에서 아이템에 대한 특성을 수집한다.
임의 속성에서 아이템에 대한 대화 스레드를 만든다.
사람이 작성한 템플릿을 사용하여 스레드를 기반으로 대화를 시뮬레이션한다.

Pre-training Stage : Domain-Adaptive Masked Prediction & Contrastive Contexts Alignment Fine-tuning Stage : 시뮬레이션된 데이터셋에서 top-𝑘 사용자와 response 표현을 검색하여 추천과 응답 생성 성능을 향상시킨다.

Contrastive Contexts Alignment

서로 다른 문맥(context) 간의 대조적 정렬(alignment)을 통해 모델의 성능을 향상시키는 방법
대조적 학습 : 두 개의 서로 다른 문맥이나 샘플을 비교하여 이들 간의 유사성과 차이를 학습한다. 이를 통해 모델은 특정 문맥에서 중요한 특징을 더 잘 이해하게 된다. 문맥 정렬 : 서로 다른 문맥에서 얻은 표현을 정렬하여, 유사한 의미를 가지는 표현들이 가까이 위치하도록 한다. 이를 통해 모델은 다양한 상황에서도 일관된 성능을 발휘할 수 있게 된다. 성능 향상 : 대조적 문맥 정렬을 통해 모델은 다양한 상황에서의 일반화 능력을 향상시키고, 특히 희귀한 데이터나 long-tail 문제를 다루는 데 유리하다.

1. Introduction

문제점 : 대부분의 기존 CRS는 데이터에 의존적이며, 고품질 CRS 데이터셋의 가용성에 성능이 크게 좌우된다. 하지만 기존 CRS 데이터셋에서 long-tail 현상이 두드러지며, 많은 아이템이 대화에서 거의 언급되지 않거나 전혀 언급되지 않는다. 이로 인해 학습된 CRS는 자주 등장하는 아이템에 치우친 추천을 하게 되어, 추천 아이템의 다양성이 줄어든다.

기존 접근법 : 기존 연구는 resampling, 인스턴스 가중치 조정, 정규화 방법 등을 사용했으나, CRS의 long-tail 문제를 해결하기에는 두 가지 해결 과제가 있다. 첫째, 대화 맥락을 이해하는 데 필요한 증거를 충분히 포착하기 어렵고, 둘째, 사용자 선호를 정확하게 추론하는 데 필요한 학습 신호가 부족하다.

제안 방법 : 본 논문에서는 CRS의 long-tail 추천 문제를 해결하기 위한 새로운 프레임워크 LOT-CRS를 제안한다. 이 프레임워크는 공공 아이템 속성을 활용하여 균형 잡힌 CRS 데이터셋을 시뮬레이션하고, 이를 통해 데이터 부족 문제를 해결한다.

전략 : 시뮬레이션된 데이터를 기반으로 두 가지 사전 학습 과제(도메인 적응형 마스크 예측, 대조적 문맥 정렬)를 설계하고, 검색 보강 학습 전략을 채택하여 대화 맥락을 풍부하게 한다. 또한, 시뮬레이션된 대화로 학습된 CRS 모델을 사용하여 long-tail 아이템을 추천하는 데 도움을 준다.

결과 : 제안된 접근법은 long-tail 추천 성능을 효과적으로 향상시켜 기존 PLM 기반 CRS의 성능을 극대화할 수 있음을 보여준다. 이는 대화형 추천 시스템에서 long-tail 문제를 완화하기 위한 첫 번째 시도이다.

4. Approach

4.1 PLM 기반 CRS 방법

최근 Transformer 아키텍처를 기반으로 한 PLM(Pre-trained Language Models)과 대형 언어 모델(LLM)이 텍스트 및 대화 이해 작업에서 우수성을 보여주었다. 기존 CRS 방법들은 PLM을 사용하여 대화 맥락을 모델링한다. 본 연구에서는 long-tail 추천을 개선하기 위해 BERT, BART, UniCRS와 같은 PLM을 사용하고, 시뮬레이션된 CRS 데이터셋으로 사전 학습을 수행하여 대화 맥락 이해를 향상시킨다.

4.2 균형 잡힌 CRS 데이터셋 시뮬레이션

기존 데이터셋은 long-tail 아이템을 충분히 고려하지 않아, 이를 해결하기 위해 균형 잡힌 CRS 데이터셋을 시뮬레이션한다. 아이템 속성(예: 설명, 리뷰)을 수집하고, 대화 스레드를 구축하여 추천 아이템을 포함한 대화를 생성한다.

4.3 균형 잡힌 시뮬레이션 데이터셋에서의 사전 학습

시뮬레이션된 데이터셋은 long-tail 아이템에 대한 중요한 증거를 포함한다. 두 가지 사전 학습 과제를 설계한다: Domain-Adaptive Masked Prediction(DMP)과 Contrastive Contexts Alignment(CCA). DMP는 아이템 및 속성 예측을 통해 PLM을 CRS에 적응시키고, CCA는 대화 맥락과 타겟 아이템 간의 관련성을 강화한다.

4.4 검색 보강 fine-tuning

시뮬레이션된 대화를 사용하여 PLM 모델을 사전 학습한 후, 실제 CRS 데이터셋으로 fine-tuning 한다. 실제 데이터셋은 제한적이거나 희소할 수 있으므로, 검색 보강 학습 아이디어를 적용하여 시뮬레이션된 대화로부터 유용한 맥락을 검색하고 이를 활용한다.

4.4.1 추천을 위한 fine-tuning

검색 강화 사용자 표현 : 시뮬레이션된 데이터에서 유사한 대화를 검색하여 사용자 표현을 보강한다. 이를 통해 사용자의 선호를 더 효과적으로 반영할 수 있다.
long-tail 아이템을 위한 라벨 스무딩(Label Smoothness) : teacher 모델을 사용하여 soft label들을 생성하고, 이를 기반으로 정규화를 진행하여 long-tail 아이템에 대한 확률을 높인다. 이를 통해 노출 편향 문제를 완화한다.

라벨 스무딩 (Label smoothness)

모델의 예측 확률 분포를 부드럽게 만드는 방법. 모델의 예측을 더 부드럽고 일반화된 형태로 만드는 데 기여하여, 특정 클래스에 대한 편향을 줄이고, 다양한 아이템을 효과적으로 추천할 수 있도록 한다.

일반화 능력 향상 : 모델이 특정 클래스(ex. frequent items)에 과도하게 적합되는 것을 방지하고, 다양한 클래스(ex. long-tail items)에 대한 예측을 더 균형 있게 만들기 위해 사용된다.
노출 편향 완화 : 특정 아이템이 자주 추천되는 경향이 있는 경우, 라벨 스무딩은 모델이 덜 자주 등장하는 아이템에 대해서도 더 높은 확률을 할당하도록 유도합니다.
Soft Labels 사용 : teacher 모델을 통해 생성된 soft label들을 사용하여, 모델이 각 클래스에 대해 단일 확률 대신 여러 클래스에 대한 확률 분포를 학습하게 합니다. 이를 통해 모델이 더 다양한 예측을 할 수 있도록 돕습니다.

4.4.2 응답 생성을 위한 fine-tuning

검색 강화 프롬프트 : 대화 기록을 인코딩하여 관련 응답을 검색하고, 이를 통해 더 유용한 응답을 생성한다.
응답 템플릿 생성 및 채우기 : PLM을 사용하여 응답 템플릿을 생성하며, 이 템플릿 내의 아이템 토큰을 추천된 아이템으로 채운다. 이를 통해 자연스럽고 정보가 풍부한 응답을 제공한다.

5. Experiment

5.1 실험 설정

데이터셋 : ReDial과 INSPIRED 두 개의 영어 CRS 데이터셋을 사용하여 접근법의 효과를 검증하였다. ReDial은 영화 추천을 다루며, Amazon Mechanical Turk를 통해 구축되었다. INSPIRED 역시 영화 추천 데이터셋이지만, 규모가 더 작다.
기준 모델 : 여러 경쟁력 있는 방법(기존 CRS 모델 및 PLM)을 기준으로 선택하여 추천과 대화 두 가지 하위 작업에서 평가하였다. 주요 모델로는 HRED 기반의 ReDial, KG(Knowledge Graph)를 활용한 KBRD와 KGSF, PLM 기반의 GPT-2, DialoGPT, BERT, BART, UniCRS가 포함된다.

Baseline 모델

ReDial : HRED 기반의 대화 모듈과 auto-encoder 기반의 추천 모듈을 통합한 모델이다.
KBRD : 외부 지식 그래프(KG)를 활용하여 대화 이력의 entity를 강화하고, self-attention 기반 추천 모듈과 Transformer 기반 대화 모듈을 사용한다.
KGSF : 두 개의 KG를 통합하여 단어와 entity의 표현을 강화하고, 상호 정보 최대화(Mutual Information Maximization) 방법을 사용하여 두 KG의 의미 공간을 정렬한다.
GPT-2 : auto-regressive PLM으로, 대화 맥락을 입력으로 사용하여 생성된 텍스트를 응답으로, 마지막 토큰의 표현을 추천으로 활용한다.
DialoGPT : 대규모 대화 코퍼스에서 사전 학습된 auto-regressive 모델로, 생성된 텍스트를 응답으로, 마지막 토큰 표현을 추천으로 사용한다.
BERT : masked 언어 모델 작업을 통해 사전 학습된 모델로, 추천을 위해 [CLS] 토큰의 표현을 활용한다.
BART : denoising auto-encoding 작업으로 사전 학습된 Seq2Seq 모델로, 생성된 텍스트를 응답으로, 마지막 토큰 표현을 추천으로 사용한다.
UniCRS : 추천과 대화 작업을 모두 수행하는 통합 모델로, 고정된 PLM에서 지식 강화 프롬프트 학습을 사용한다.

HRED (Hierarchical Recurrent Encoder-Decoder)

: HRED는 대화 시스템에서 문맥을 효과적으로 처리하고, 사용자와의 상호작용에서 더 자연스럽고 일관된 응답을 생성하는 데 도움을 준다. 이러한 특성 덕분에 HRED는 대화형 추천 시스템(CRS) 및 기타 대화형 AI 애플리케이션에 널리 사용되고 있다.

계층적 구조 : HRED는 대화의 문맥을 이해하기 위해 두 개의 수준(문맥과 응답)으로 나누어 인코딩한다. 이는 대화의 전체적인 흐름과 각 발화의 의미를 동시에 고려할 수 있게 한다.
인코더-디코더 아키텍처 : HRED는 인코더-디코더 구조를 기반으로 하여, 입력된 대화의 문맥(이전 발화들)을 인코딩하고, 이를 바탕으로 적절한 응답을 생성한다.
순환 신경망(RNN) 활용 : HRED는 RNN을 사용하여 시퀀스 데이터를 처리하며, 대화의 시간적 특성을 잘 반영할 수 있다.
평가 지표 : 추천과 대화 작업을 평가하기 위해 Recall@𝑘, Coverage@𝑘, Tail-Coverage@𝑘, Distinct-𝑛 등 다양한 지표를 사용하였다. Fluency와 Informativeness 측면에서 수작업 평가도 시행하였다.

평가 지표

Recall@k

추천 시스템이 상위 k개의 추천 목록에서 실제로 사용자가 선호하는 아이템을 얼마나 잘 추천하는지를 평가하는 지표
목적 : 추천의 정확성을 측정하며, k의 값에 따라 다양한 수준의 추천 성능을 평가할 수 있다.
Coverage@k
전체 추천 목록에서 얼마나 많은 다양한 아이템이 포함되었는지를 측정하는 지표
공식 : $Coverage@k = \frac{|C \in C , L_k(C)|}{|I|}$, 여기서 $L_k(C)$는 대화 C에 대한 상위 k개의 추천 아이템 목록을 나타낸다.
목적 : 추천 결과의 다양성을 평가하여, 추천 시스템이 다양한 아이템을 추천하는지를 확인한다.
Tail-Coverage@k
전체 추천 목록에서 long-tail 아이템(빈도가 낮은 아이템)이 얼마나 많이 추천되었는지를 측정하는 지표
공식 : $Tail_Coverage@k = \frac{|C \in C , L^T_k(C)|}{|I(T)|}$, 여기서 $L^T_k(C)$는 long-tail 아이템으로 구성된 상위 k개의 추천 목록이다.
목적 : long-tail 아이템의 추천 성과를 평가하여, 추천 시스템의 균형 잡힌 추천 능력을 확인한다.
Distinct-n
생성된 응답을 n-그램 기반으로 계산하여 단어 수준에서 다양성을 측정하는 지표
목적 : 추천 시스템이 생성하는 응답의 다양성을 평가하여, 반복적인 응답을 피하고 다양한 답변을 생성하는 능력을 확인한다.
Fluency / Informativeness
수작업 평가를 통해 생성된 응답의 유창성과 정보량을 0에서 2까지의 점수로 평가하는 지표
목적 : 추천 시스템이 생성하는 응답의 질을 주관적으로 평가하여, 실제 사용자 경험을 반영한다.

5.2 추천 성능 평가

자동 평가 : 다양한 방법의 추천 정확도 및 long-tail 메트릭을 평가하였다. KG 기반 CRS 방법이 PLM 기반 방법과 경쟁력 있는 성능을 보였으며, 특히 UniCRS가 대부분의 지표에서 최상의 성능을 기록하였다. 제안된 접근법은 BERT, BART, UniCRS의 성능을 향상시켰다.
Long-tail 방법과의 성능 비교 : Class-Balanced Softmax Cross-Entropy Loss 및 Regularization 방법과 비교하여, 제안된 접근법이 보다 효과적으로 long-tail 문제를 해결함을 보였다. Regularization 방법으로는 Balanced Group Softmax를 사용했다.

Class-Balanced Softmax Cross-Entropy Loss

목적 : 데이터셋에서 클래스 불균형 문제를 해결하기 위해 설계된 손실 함수이다. 일반적인 Softmax Cross-Entropy Loss은 다수 클래스에 대해 모델이 과도하게 학습하는 경향이 있어, 소수 클래스의 성능이 저하될 수 있다.
작동 원리
- 클래스 불균형을 해결하기 위해, 각 클래스에 가중치를 부여하여 손실 계산 시 소수 클래스의 중요성을 높인다.
- 가중치는 각 클래스의 샘플 수에 기반하여 조정되며, 일반적으로는 $w_i = \frac{N}{C \cdot n_i}$로 계산된다. 여기서 $N$은 전체 샘플 수, $C$는 클래스 수, $n_i$는 클래스 $i$의 샘플 수이다.
- 이 가중치를 사용하여 손실 함수를 계산함으로써, 소수 클래스에 대한 손실이 더 크게 반영되어 모델이 균형 잡힌 학습을 할 수 있도록 한다.
  Regularization
목적 : 모델이 학습 데이터에 과적합(overfitting)되는 것을 방지하기 위해 사용된다. Regularization은 모델의 복잡성을 줄이고, 일반화 성능을 향상시키는 역할을 한다.
주요 유형
- L1 Regularization (Lasso) : 모델의 가중치에 대한 절대값 합을 손실 함수에 추가한다. 이로 인해 일부 가중치가 0으로 수렴하여, 변수 선택 효과를 가져온다.
- L2 Regularization (Ridge) : 모델의 가중치에 대한 제곱합을 손실 함수에 추가한다. 이는 모든 가중치가 작아지도록 유도하여, 모델의 복잡성을 줄인다.
- Dropout : 학습 과정에서 일정 비율의 뉴런을 무작위로 비활성화하여, 네트워크가 특정 뉴런에 의존하지 않도록 한다. 이로 인해 더 강건한 모델이 학습된다.
  이 두 가지 방법은 각각 클래스 불균형 문제와 과적합 문제를 해결하는 데 효과적이며, 특히 long-tail 데이터셋에서 모델의 성능을 향상시키는 데 중요한 역할을 한다.

Balanced Group Softmax 그룹화 : 클래스 간의 불균형을 완화하기 위해 그룹별로 소프트맥스 함수를 조정하여 각 클래스의 기여도를 균형 있게 만든다. 가중치 조정 : 각 클래스의 중요도에 따라 가중치를 조정하여 학습 과정에서 덜 나타나는 클래스를 더 잘 학습하도록 유도한다.

Ablation Study : UniCRS를 기준으로 여러 구성 요소의 효과를 검증하였다. DMP와 CCA, label smoothness, retrieval-augmented 전략을 제거할 경우 성능 저하가 발생함을 확인하였다.
하이퍼파라미터 분석 : 사용자 표현을 검색하는 수와 그 가중치를 조정하여 성능에 미치는 영향을 평가하였다. 적절한 값 설정이 필요함을 강조하였다.

5.3 대화 성능 평가

자동 평가 : PLM 기반 방법이 다른 CRS 방법보다 일관되게 우수한 성능을 보였다. 특히 DialoGPT가 가장 높은 성능을 기록하였으며, UniCRS도 다른 기준 모델보다 우수한 성능을 발휘하였다. 제안된 접근법은 BERT, UniCRS의 성능을 향상시켰다.
인간 평가 : KGSF, DialoGPT, UniCRS와 비교하여 제안된 접근법이 가장 높은 성능을 보였다. 시뮬레이션된 균형 잡힌 CRS 데이터셋을 통해 대화 역사 이해와 정보 생성 능력이 향상되었다.
Ablation Study : 대화 작업에 대한 여러 구성 요소의 효과를 검증하였다. retrieval-augmented 전략이 다른 전략보다 더 중요한 것으로 나타났으며, 성능 저하가 더 크게 발생하였다.
데이터 부족 시나리오 : 학습 데이터의 비율을 조정하여 제안된 접근법이 데이터 부족 문제를 얼마나 잘 해결하는지 평가하였다. 제안된 방법이 모든 경우에서 우수한 성능을 나타냈다. 이는 LOT-CRS가 제한된 레이블이 지정된 데이터를 더 잘 활용하고 특히 롱테일 권장 사항에 대해 콜드 스타트 문제를 완화할 수 있음을 나타낸다.

5.4 정성적 분석

사용자와 CRS 간의 대화 예시는 제안된 접근법의 효과를 보여준다. 사용자 요청에 대해 적절한 영화를 추천하는 과정에서, 시뮬레이션된 데이터셋을 활용하여 관련된 대화를 검색하고, 이를 통해 적합한 추천을 수행하였다. 이러한 실험 결과는 제안된 접근법이 대화형 추천 시스템에서 long-tail 문제를 완화하는 데 효과적임을 나타낸다.

6. Conclusion

본 논문에서는 대화형 추천 시스템(CRS)의 long-tail 추천을 향상시키기 위한 새로운 프레임워크인 LOT-CRS를 제안하였다.

LOT-CRS

균형 잡힌 CRS 데이터셋 시뮬레이션 : 데이터 부족 문제를 해결하기 위해, 공개적으로 수집된 아이템 속성을 활용하여 다양한 아이템이 고르게 포함된 CRS 데이터셋을 인위적으로 생성하는 과정이다. 이를 통해 long-tail 아이템 추천의 기반이 되는 데이터셋을 마련한다.

PLM 기반의 두 가지 사전 학습 과제 : 시뮬레이션된 데이터를 사용하여 두 가지 사전 학습 과제를 설계했다. 첫 번째는 도메인 적응형 마스크 예측(Domain-Adaptive Masked Prediction)으로, 대화 맥락을 이해하는 데 필요한 정보를 주입하는 역할을 한다. 두 번째는 대조적 문맥 정렬(Contrastive Context Alignment)로, 대화 맥락과 추천 아이템 간의 관련성을 강화한다.
검색 보강 학습 및 라벨 스무딩 전략 : 시뮬레이션된 데이터셋을 활용하여 long-tail 아이템의 추천 성능을 개선하는 방법이다. 검색 보강 학습은 유사한 대화를 검색하여 추천의 품질을 높이고, 라벨 스무딩은 모델의 예측을 부드럽게 하여 다양한 아이템을 추천할 수 있도록 한다.

이러한 접근법은 다양한 PLM 기반 CRS의 long-tail 추천 향상에 적용 가능하며, 광범위한 실험을 통해 여러 PLM 기반 CRS 방법의 성능을 높일 수 있음을 보여주었다.

[논문] LLM-Rec: Personalized Recommendation via Prompting Large Language Models

Thu, 27 Feb 2025 08:48:15 GMT

📄 Paper

LLM-Rec: Personalized Recommendation via Prompting Large Language Models [arxiv]

Hanjia Lyu NAACL 2024

📝 Key Point

LLM-Rec 프레임워크 : LLM을 활용하여 개인화된 추천을 개선하는 새로운 접근법인 LLM-Rec을 제안한다. 이 프레임워크는 입력 텍스트 보강을 통해 추천 품질을 향상시킨다.
프롬프트 전략 : LLM-Rec은 기본 프롬프트, 추천 주도 프롬프트, 참여 유도 프롬프트, 추천 주도 + 참여 유도 프롬프트로 구성된 4가지 전략을 사용하여 아이템 설명을 보강한다.
성능 향상 : LLM-REC는 보강된 텍스트와 원래 아이템 설명을 결합하여 추천 성능을 크게 향상시킨다. 간단한 모델인 MLP도 복잡한 모델과 동등하거나 더 나은 성과를 낸다.
유연성 및 적용 가능성 : LLM-Rec은 다양한 도메인에 적용 가능하며, 데이터셋의 텍스트 정보가 풍부하지 않더라도 효과적으로 작동한다.
투명성과 설명 가능성 : 보강된 텍스트를 통해 추천 과정의 투명성을 높이고, 추천 이유를 사용자와 시스템 설계자가 이해하는 데 도움을 준다.

Abstract

배경 : 텍스트 기반 추천 시스템은 다양한 응용 가능성을 지니지만, 원래의 아이템 설명을 직접 사용하는 것이 사용자 선호와 일치하지 않아 최적의 성능을 발휘하지 못할 수 있다.

연구 목적 : LLM의 상식 지식과 추론 능력을 활용하여 개인화된 텍스트 기반 추천을 개선하기 위한 새로운 접근법인 LLM-Rec을 제안한다.

방법론 : LLM-Rec은 네 가지의 텍스트 보강 프롬프트 전략을 포함하여 추천 품질을 향상시킨다.

실험 결과 : LLM으로 보강된 텍스트를 사용한 경우 추천 품질이 크게 향상되며, 기본적인 다층 퍼셉트론(MLP) 모델조차도 복잡한 콘텐츠 기반 방법보다 우수한 성과를 낸다.

결론 : LLM-Rec의 성공은 다양한 프롬프트 전략에 있으며, 이는 언어 모델의 아이템 특성 이해를 효과적으로 활용함을 보여준다. 따라서 다양한 프롬프트와 입력 보강 기법의 사용이 추천 효과성을 높이는 데 중요하다.

Figure

LLM-REC는 아이템 설명을 보강하기 위해 4가지 프롬프트 전략을 사용한다. 증강 된 텍스트를 연결하여 추천 모델의 input으로 사용한다.

Basic Prompting The description of an item is as follows: '{description}', paraphrase it.
Recommendation-driven Prompting “The description of an item is as follows: '{description}', what else should I say if I want to recommend it to others?
Engagement-guided Prompting Summarize the commonalities among the following descriptions: '{description}'; '{descriptions of other important neighbors}'
Recommendation + Engagement The description of an item is as follows: '{description}'. What else should I say if I want to recommend it to others? This content is considered to hold some similar attractive characteristics as the following descriptions: '{descriptions of other important eighbors}'.

1. Introduction

배경 : 텍스트 기반 추천 시스템은 다양한 도메인과 산업에서 폭넓은 응용 가능성을 지닌다. 자연어의 특성 덕분에 제품, 영화, 책, 뉴스 기사, 사용자 생성 콘텐츠 등 거의 모든 유형의 아이템을 효과적으로 설명할 수 있다.

문제점 : 그러나 이러한 추천 시스템은 아이템 설명의 불완전성으로 인해 사용자 선호와 아이템 특성을 정확히 일치시키는 데 어려움을 겪는다. 불완전성은 두 가지 원인으로 발생할 수 있는데, 첫째는 아이템의 이해 부족, 둘째는 추천 대상 사용자의 이해 부족이다.

연구 목적 : 이 연구에서는 LLM의 내재적 능력을 활용하여 입력 텍스트를 보강하는 다양한 프롬프트 전략을 채택한 LLM-Rec 프레임워크를 소개한다. 이를 통해 개인화된 추천의 품질을 향상시키고자 한다.

실험 결과 : LLM-Rec 프레임워크의 효과를 평가한 결과, 보강된 텍스트를 새로운 입력으로 사용했을 때 기존의 아이템 설명만을 사용하는 콘텐츠 기반 추천 방법보다 동등하거나 더 나은 성과를 낸다.

결론 : 다양한 도메인에 적용 가능하며, LLM의 프롬프트 전략이 일반 및 구체적인 아이템 특성을 표현하는 데 효과적임을 보여준다. 이 연구는 추천 성과에 대한 다양한 프롬프트 전략의 영향을 탐구하고 LLM을 개인화 추천에 활용할 가능성을 제시한다.

LLM-Rec은 LLM 프롬프트를 통해 중요한 키워드를 증강하여 아이템 설명을 강화한다. 따라서 다양한 도메인에 데이터셋 제한 없이 적용될 수 있다.

3. LLM-Rec

목표 : LLM-Rec은 LLM을 활용하여 정보성 있는 아이템 설명을 생성하고, 이를 통해 개인화 추천을 향상시키는 방법을 탐구한다.

프롬프트 전략 : 본 연구는 네 가지의 프롬프트 전략을 통해 설명을 보강하는 데 초점을 맞춘다.

기본 프롬프트 (Basic Prompting) $p_{para}$ : 원래 아이템 설명을 패러프레이즈하여 동일한 정보를 유지한다. $p_{tag}$ : 내용을 태그로 요약하여 핵심 정보를 캡처한다. $p_{infer}$ : 아이템 설명의 특성을 추론하여 감정과 같은 범주적 응답을 제공한다.
- 추천 주도 프롬프트 (Recommendation-driven Prompting) $p^{rec}{para}$ : 추천을 위한 추가 정보를 생성한다. $p^{rec}{tag}$ : 추천에 적합한 태그를 생성한다. $p^{rec}_{infer}$ : 감정 중심으로 추천한다.
참여 유도 프롬프트 (Engagement-guided Prompting) 사용자와 아이템 간의 상호작용을 기반으로 더 정확한 설명을 생성한다. $p^{eng}$ : 타겟 아이템 설명과 관련된 중요한 이웃 아이템 설명을 결합하여 공통점을 요약한다.
추천 주도 + 참여 유도 프롬프트 (Recommendation-driven + Engagement-guided Prompting) $p^{rec+eng}$ : 두 가지 전략을 통합하여 더 정교한 추천을 생성한다.

효과

개인화 추천 성능 : LLM-Rec은 다양한 아이템 유형에 제한받지 않고 개인화 추천에서 상당한 개선을 보여준다. 간단한 모델인 다층 퍼셉트론(MLP)조차도 복잡한 모델과 동등하거나 더 나은 성과를 낸다.
투명성과 설명 가능성 : LLM-Rec은 추천 과정의 투명성과 설명 가능성을 높인다. 보강된 텍스트를 직접 조사함으로써 추천 모델과 아이템 특성에 대한 이해를 증진시켜 사용자와 시스템 설계자에게 유용한 통찰을 제공한다.

결론 : LLM-Rec은 이전 연구보다 적은 도메인 전문 지식으로도 구현 가능하며, 추천 성과를 향상시키는 데 효과적이다.

4. Experiment

4.2 Main Results

추천 성능 향상 : LLM-Rec으로 보강된 텍스트는 추천 성능을 크게 향상시킨다. Movielens1M에서 NDCG@10이 6.24%에서 8.54%로, Recipe에서 8.97%에서 21.72%로 증가한다.

$p^{rec}{para}$의 response에서 특정 단어를 마스킹했을 때, 추천 성능이 눈에 띄게 감소했다. 이는 $p^{rec}{para}$의 고유 단어들이 추천 성과에 중요한 역할을 한다는 것을 입증한다.

$p^{keyword}{para}$는 $p^{rec}{para}$의 response에 사용자 선호와 관련된 키워드를 추가하여 성능을 더욱 향상시킬 수 있음을 나타낸다.
LLM-Rec의 보강된 텍스트에서 생성된 특정 단어들이 추천 성능에 중요한 기여를 하기 때문에 단어 선택의 중요성을 강조한다. 또한, 모든 응답 단어를 포함하는 것보다는 중요한 키워드를 선택적으로 포함시키는 것이 더 효과적임을 보여준다.

추가 정보 효과 : LLM-Rec의 프롬프트 접근법이 제공하는 추가 정보에 대한 정성적 및 정량적 연구를 통해 보강된 내용이 더 상세하고 표현력이 뛰어난 설명을 포함하고 있음을 발견했다.

지식 보강 접근법과 비교 ex) KAR (Knowledge Augmented Recommendation)

지식 보강 접근법은 생성된 지식이 특정 아이템과 맞지 않을 수 있기 때문에 추천 성능을 최적화하지 못한다.
예를 들어, 특정 레시피에 대한 생성된 재료 정보가 대부분의 경우 정확할 수 있지만, 특정 레시피에 대한 추가 맥락이 없으면 잘못된 정보를 제공할 수 있다.
LLM-Rec은 추천 주도 프롬프트를 활용하여 특정 아이템을 더 넓고 덜 세분화된 수준에서 설명하는 정보를 제공한다.

다양한 도메인 적용 가능성 : LLM-Rec은 다양한 아이템 도메인에 적용 가능하며, 데이터셋에 따라 성능이 다르게 나타난다.

4.3 Ablation Study

프롬프트 전략 평가 : 각 프롬프트 전략이 추천 성능에 미치는 영향을 연구한 결과, 모든 전략에서 성능 향상이 나타났다. Movielens1M에서는 추천 주도와 참여 유도 전략의 조합이 가장 효과적이었다.

응답 통합 방법 : 보강된 응답을 통합하는 방법이 추천 성능에 미치는 영향을 분석한 결과, 모든 보강 텍스트를 통합했을 때 성능이 향상됨을 확인했다.

단어 선택 변경의 영향 : 프롬프트의 단어 선택을 변경한 변형을 통해 응답의 유사성을 비교한 결과, 단어 선택의 차이가 응답 형식에 영향을 미쳤지만, 기본적인 의미는 유지되었다.

5. Discussions and Conclusions

연구의 주요 내용

LLM-Rec의 효과성 : 본 연구는 LLM을 활용하여 추천 품질을 향상시키는 간단하면서도 효과적인 메커니즘인 LLM-Rec의 효용성을 연구하였다. LLM을 통해 텍스트 보강을 시도한 초기 연구 중 하나로써 가치가 있다.
LLM-Rec의 기여 :
1. 유연성 : 기존의 연구(예: KAR)는 특정 추천 모델을 위한 보강 알고리즘에 집중했지만, LLM-Rec은 모든 콘텐츠 기반 추천 모델에 적용 가능한 입력 텍스트 보강에 초점을 맞춘다.
  1. 개인화된 특성 : 추천 주도 보강 외에도 참여 유도 프롬프트를 설계하여 개인화된 아이템 특성을 포함한다.
  2. 종합적인 실험 : 다양한 프롬프트 전략 조합을 통해 LLM-Rec의 우수한 성능을 입증하며, 성능 개선의 근본적인 이유를 밝혀낸다.

결과 및 발견

추천 품질 향상 : 보강된 입력 텍스트와 원래 아이템 설명을 결합함으로써 추천 품질이 크게 향상되었다. 이는 LLM과 전략적 프롬프트 기법을 활용하여 추천의 정확성과 관련성을 높일 수 있는 잠재력을 보여준다.
세부 정보 캡처 : 추가적인 맥락을 포함시킴으로써 추천 알고리즘이 더 세밀한 정보를 포착하고 사용자 선호에 더 잘 맞는 추천을 생성하는 데 기여한다.

한계점

계산 비용 : LLM-Rec 프레임워크는 추가적인 계산 비용이 소요된다. 특히 보강 단계에서의 출력 텍스트 길이가 주된 부담이 된다. 중요한 단어를 선택하여 포함시키는 것이 전체 응답 단어를 사용하는 것보다 추천 성과를 향상시킬 수 있음을 발견하였다.
최신 정보 반영의 어려움 : LLM 기반 연구와 마찬가지로 LLM-Rec은 최신 지식을 신속하게 반영하는 데 어려움이 있다. 향후 연구에서는 LLM이 외부 소스에서 현재 지식을 자율적으로 수집하고 요약하는 방법을 탐구할 예정이다.

[논문] TALLRec: An Effective and Efficient Tuning Framework to Align Large Language Model with Recommendation

Fri, 21 Feb 2025 17:25:38 GMT

📄 Paper

TALLRec: An Effective and Efficient Tuning Framework to Align Large Language Model with Recommendation [arxiv]

Keqin Bao ACM RecSys 23

📝 Key Point

LLM을 추천 작업에 효과적으로 통합하기 위해 TALLRec 프레임워크를 제안한다.
TALLRec 프레임워크는 Alpaca Tuning과 Rec-Tuning의 두 단계로 구성된다.
TALLRec 프레임워크로 훈련된 LLM은 전통적인 추천 모델과 In-context Learning 기반 LLM 보다 더 우수한 성능을 나타냈고, 강력한 cross-domain 일반화 능력을 보여줬다.

Abstract

연구 배경 : 추천 시스템에서 LLM 연구가 진행되고 있으나, 성능이 충분하지 않다.

문제점 : LLM의 훈련 작업과 추천 작업 간의 큰 격차가 존재하며, 추천 데이터가 pre-training에 부적합하다.

제안된 방법 : 추천 데이터를 활용하여 LLM을 조정하는 "대규모 추천 언어 모델"을 구축하였고, 이를 위해 효율적이고 효과적인 조정 프레임워크인 TALLRec를 제안한다.

주요 결과 : TALLRec은 영화와 도서 분야에서 LLM의 추천 능력을 크게 향상시킬 수 있음을 보여준다. 특히, 데이터셋이 100개 미만인 경우에도 효과를 발휘하며, 단일 RTX 3090에서 LLaMA-7B 모델로 실행이 가능하다. 또한, 조정된 LLM은 강력한 도메인 간 일반화 능력을 갖추고 있다.

Figure

사용자의 상호작용 데이터가 주어지면 LLM은 In-context Learning을 통해 새로운 아이템을 사용자가 좋아할지 예측한다. 하지만 ChatGPT 같은 대표적인 LLM들은 답변을 거부하거나 항상 긍정적인 예측을 했다.

TALLRec 프레임워크는 Alpaca Tuning과 Rec-Tuning의 두 단계로 구성된다. Rec-Tuning 단계에서는 추천 데이터로 구성된 input과 output Instruction을 샘플로 사용한다. 또한, 효율성 향상을 위해 Lightweight Tuning 기법을 사용한다.

1. Introduction

LLM의 능력 : LLM은 풍부한 지식과 일반화 능력을 가지고 있으며, 적절한 Instruction을 통해 처음 보는 작업을 해결할 수 있다.

추천 분야 : LLM의 특성은 추천 시스템에서 강력한 일반화와 풍부한 지식을 요구하는 문제를 해결할 수 있지만 추천 시스템에 LLM을 통합하는 연구는 제한적인 관심을 받았다.

초기 시도의 한계 : 초기에는 LLM을 전통적인 추천 모델의 도구로 사용하여 후보 아이템을 재정렬하는 방식이었으나, 성능이 전통 모델과 유사한 수준에 그쳤다. In-context Learning 만으로는 추천이 어려울 수 있다.

문제 원인 : LLM 훈련에 사용된 언어 처리 작업과 추천 작업 간의 큰 차이가 있다. 기존 추천 모델의 한계로 인해 후보 리스트가 제한된다.

제안된 해결책 : Large Recommendation Language Model(LRLM)을 구축한다. LLM을 추천 작업에 맞게 조정하는 경량 조정 프레임워크인 TALLRec을 제안한다. TALLRec은 추천 데이터를 Instruction으로 구조화하고 LLM을 조정하여 효율적으로 실행된다.

실험 결과 : TALLRec 프레임워크를 사용하여 영화와 도서 분야에서 LLM이 전통적인 추천 모델과 GPT-3.5보다 우수한 성능을 보였다.

기여 : LLM과 추천을 통합하는 새로운 문제를 연구하고 In-context Learning 기반 접근 방식의 한계를 밝혔다. TALLRec 프레임워크를 통해 LLM을 추천에 효과적으로 통합할 수 있는 방법을 제시했다. 다양한 도메인에서의 강력한 일반화 능력을 입증했다.

2. TALLRec

2.1 Preliminary

Instruction Tuning

LLM을 사람이 작성한 Instruction과 response로 훈련한다.

Step 1 : Task를 정의하고, 자연어로 "Task Instruction" 작성한다. Step 2 : "Task input"과 "Task output"을 자연어로 형식화한다. Step 3 : "Task Instruction"과 "Task input"을 결합하여 "Instruction input"을 생성하고, "Task output"을 "Instruction output"으로 사용한다. Step 4 : LLM을 "Instruction input"과 "Instruction output"의 쌍으로 조정한다.
Rec-tuning Task Formulation
- LLM을 활용하여 사용자가 새로운 아이템을 좋아할지 예측하는 LRLM을 구축한다.
- 추천 데이터를 Instruction Tuning 패턴으로 형식화하여 사용한다.
- 사용자의 과거 상호작용을 기반으로 새로운 아이템에 대한 이진 응답(예/아니오)을 생성하는 "Task Instruction"을 작성한다.

2.2 TALLRec Framework

TALLRec의 목적
- LLM을 추천 작업과 효과적이고 효율적으로 조화시키기 위한 프레임워크이다.
- 낮은 GPU 메모리 소비 환경에서 작동하도록 설계되었다.
TALLRec Tuning Stages
- Alpaca Tuning : LLM의 일반화 능력을 향상시키기 위한 과정으로, self-instruct 데이터를 활용한다.
- Rec-tuning : 추천 작업을 위한 LLM 튜닝 단계로, Alpaca Tuning과 유사한 방식으로 진행한다.
Lightweight Tuning
- LLM 튜닝이 계산 집약적이고 시간 소모적이므로 경량 튜닝 전략을 제안한다.
- LoRA를 사용하여 사전 학습된 모델의 매개변수를 고정하고, 각 레이어에 학습 가능한 행렬을 도입하여 효율적으로 튜닝한다.
Backbone Selection
- 다양한 LLM이 존재하지만, 많은 모델이 매개변수나 API에 접근할 수 없어 활용이 어렵다.
- 데이터 보안 문제도 중요하므로, 공개 LLM인 LLaMA를 선택하여 추천 목적에 맞게 매개변수를 업데이트하고 실험을 진행했다.

3. Experiments

Research Question

RQ1 : TALLRec의 성능은 현재 LLM 기반 및 전통적인 추천 모델과 어떻게 비교되는가?
RQ2 : TALLRec의 다양한 구성 요소가 효과성에 어떤 영향을 미치는가?
RQ3 : TALLRec는 교차 도메인 추천에서 어떻게 수행되는가?

Baseline

LLM 기반 방법 : In-context Learning을 사용하여 추천 생성.
전통적인 방법 : Sequential Recommendation 모델 (GRU4Rec, Caser, SASRec, DROS)

3.1 성능 비교 (RQ1)

TALLRec은 전통적인 방법과 LLM 기반 방법 모두에서 뛰어난 성능을 보였다.
LLM 기반 방법은 무작위 추측 수준(AUC ≈ 0.5)에 머물렀으나, TALLRec는 유의미한 개선을 달성했다.
전통적인 방법은 제한된 샘플로 추천 능력을 신속하게 학습하는 데 어려움을 겪었다.

3.2 Ablation Study (RQ2)

TALLRec의 alpaca tuning과 rec-tuning의 효과를 입증하기 위해 "AT"(alpaca tuning만 수행)와 "RT"(rec-tuning만 수행)의 성능을 비교했다.
rec-tuning의 중요성이 확인되었으며, 적은 rec-tuning 샘플에서도 TALLRec가 높은 성능을 유지했다.

3.3 Cross-domain 일반화 성능 분석 (RQ3)

TALLRec은 영화 샘플만 튜닝해도 책 데이터에서 좋은 성능을 보였으며, 두 도메인에서의 데이터 통합이 일반화 성능을 향상시킴을 보여준다.

5. Conclusion

연구 목적 : LLM을 추천 작업에 활용할 수 있는 가능성을 탐구하였다.

문제 발견 : 기존의 최고의 LLM 모델조차 추천 작업에서 성능이 좋지 않음을 확인하였다.

TALLRec 프레임워크 제안 : LLM과 추천 작업을 효율적으로 통합할 수 있는 TALLRec 프레임워크를 제안, 두 가지 튜닝 단계(alpaca tuning과 rec-tuning)를 통해 구현하였다.

실험 결과 : TALLRec 프레임워크로 훈련된 LLM은 전통 모델보다 우수한 성능을 보였고, 강력한 cross-domain 일반화 능력을 보여주었다.

향후 계획 : 더 큰 모델의 추천 능력을 활성화하는 효율적인 방법을 탐구하고, LLM이 여러 추천 작업을 동시에 처리할 수 있도록 튜닝할 계획이다.

jaegwon-lee.log

[프로젝트] GraphSAGE 기반 음악 추천 시스템

음악 추천 서비스 Au-Dionysos에 사용된 GraphSAGE 구현 코드 리뷰

추천 파이프라인

폴더 구조

GraphSAGE - CF Model

train_cf_model.py

1. 모듈 불러오기

2. 설정

3. 데이터 전처리

4. Edge

5. DataLoader

6. 모델 정의

7. Train / Validation

8. Feature 모델 평가

9. Test

[논문] TokenRec: Learning to Tokenize ID for LLM-based Generative Recommendations

📄 Paper

TokenRec: Learning to Tokenize ID for LLM-based Generative Recommendations [arxiv]

📝 3줄 요약

Abstract

배경

제안 방법 : TokenRec

실험 및 결과

결론

Figure

TokenRec 프레임워크

LLM 기반 추천 시스템에서 ID 토큰화 방법 비교

1. Introduction

배경

제안 방법 : TokenRec

주요 기여

2. The Proposed Method

2.1 Notations and Definitions

2.2 An Overview of the Proposed Framework

MQ-Tokenizer for Users and Items

Generative Retrieval for Recommendations

2.3 Masked Vector-Quantized Tokenizers for Users and Items

1) Collaborative Knowledge

2) Masking Operation

3) K-way Encoder and Codebook

4) K-to-1 Decoder

5) Learning Objective

2.4 Generative Retrieval for Recommendations

1) Tokenization & Prompts

사용자·아이템 ID의 효율적인 토크나이징

프롬프트 설계

2) User Modeling via LLM

입력 구성

사용자 표현 생성

3) Generative Retrieval

기존 방식의 한계

제안 방식 : 생성 기반 검색

유사도 기반 아이템 검색

2.5 TokenRec’s Training and Inference

1) Training

Step 1. 사용자 및 아이템 MQ-Tokenizer 학습

Step 2. LLM4Rec 튜닝 (Generative Retrieval)

2) Inference

효율적인 추천

새로운 사용자 및 아이템에 대한 범용성

간결한 프롬프트

3. Experiment

3.1 Experimental Settings

Datasets

Baselines

Evaluation Metrics

Hyper-parameter Settings

3.2 Performance Comparison of Recommender Systems

관찰 결과

3.3 Generalizability Evaluation

실험 설정

관찰 결과

3.4 Efficiency Evaluation

3.5 Ablation Study

3.6 Hyper-parameter Analysis

Effect of Masking Ratio $\rho$

Effect of Codebook Settings K and L

4. Related Work

Collaborative Filtering