<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by chrisjune on Medium]]></title>
        <description><![CDATA[Stories by chrisjune on Medium]]></description>
        <link>https://medium.com/@chrisjune-13837?source=rss-e74406582b08------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*Uya0gopzDrs0VynkAs3AEg.png</url>
            <title>Stories by chrisjune on Medium</title>
            <link>https://medium.com/@chrisjune-13837?source=rss-e74406582b08------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 04:22:09 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@chrisjune-13837/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[딸깍으로 안되는 Multi-interest 모델 개발기]]></title>
            <link>https://medium.com/kream-%EA%B8%B0%EC%88%A0-%EB%B8%94%EB%A1%9C%EA%B7%B8/%EB%94%B8%EA%B9%8D%EC%9C%BC%EB%A1%9C-%EC%95%88%EB%90%98%EB%8A%94-multi-interest-%EB%AA%A8%EB%8D%B8-%EA%B0%9C%EB%B0%9C%EA%B8%B0-27f79d039d5d?source=rss-e74406582b08------2</link>
            <guid isPermaLink="false">https://medium.com/p/27f79d039d5d</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[chrisjune]]></dc:creator>
            <pubDate>Thu, 05 Nov 2026 05:05:18 GMT</pubDate>
            <atom:updated>2026-11-05T05:05:18.571Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>추천 모델이 같은 상품을 모두에게 보여준 사고의 원인과 해결 기록</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LNXrIASfakyLWHr-SfvbAg.png" /><figcaption>Hubness</figcaption></figure><p>안녕하세요! KREAM의 추천서비스 엔지니어 최준영입니다.</p><p>지난 글 <a href="https://medium.com/kream-%EA%B8%B0%EC%88%A0-%EB%B8%94%EB%A1%9C%EA%B7%B8/%EB%B0%91%EB%B0%94%EB%8B%A5%EC%97%90%EC%84%9C-%EA%B0%9C%EC%84%A0%ED%95%9C-%EC%B6%94%EC%B2%9C%EC%8B%9C%EC%8A%A4%ED%85%9C-with-two-tower-model-e940817af2bb">밑바닥에서 개선한 추천시스템 with Two-Tower Model</a> 마지막에 유저 행동 시퀀스를 반영하는 기법은 다음에 소개하겠다고 적었는데 이 글에서 그 이야기를 이어 가려고 합니다.</p><p>모델 구조 자체보다는 논문 구조를 그대로 가져와 적용했을 때 실서비스에서 무엇이 문제가 되고 어떻게 대응했는지 다루겠습니다.</p><h3>모델이 사용된 지면</h3><p>먼저 추천 지면 세 곳을 먼저 소개합니다. 모델 하나를 세 지면에 적용했고 세번째 (인기 상품 목록) 지면에서 문제가 두드러졌습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tgsUtdsep14x64inrncl4g.png" /><figcaption><em>왼쪽부터 카테고리 추천, 무한 스크롤 피드, 인기 상품 목록</em></figcaption></figure><ul><li><strong>카테고리 추천</strong>: 모델을 retrieval로 사용하여 대표 카테고리 상품 한개씩을 보여줍니다.</li><li><strong>무한 스크롤 피드</strong>: 이 지면도 모델을 retrieval로 사용하여 무한 스크롤 피드를 제공합니다.</li><li><strong>인기 상품 목록</strong>: 인기 상품 상위 3000개를 후보로 사용하여 모델을 re-ranker로 사용한 지면입니다.</li></ul><h3>모두에게 비슷하게 추천하는 문제</h3><p>9월 초에 <em>인기 상품 목록</em>에서 특정 상품들이 자주 노출된다는 리포트를 받았습니다. 처음 며칠은 클릭할 만한 인기 상품이라고 생각하고 넘겼습니다. 당시에는 오프라인 지표에도 A/B 지표에도 같은 상품이 얼마나 많은 유저에게 노출되는지를 보는 지표가 없어서 리포트 외에는 이 현상을 알아챌 방법이 없었습니다.</p><p>동료들의 계정을 확인 한 후에 문제임을 인지하게 되었고 임시로 문제 되는 상품들의 노출을 낮추는 대응을 하였습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LYw08cMamXOD2TfPEVs8hw.png" /><figcaption><em>탐색 이력과 무관하게 여러 유저에게 동시에 노출된 상품 5개</em></figcaption></figure><p>이 상품들은 유저와 상관없이 반복해서 상단에 노출되었고 그만큼 개인화 상품은 노출 기회를 잃었습니다.</p><p>본문에서 계속 사용할 지표 두 가지를 먼저 정의하겠습니다.</p><ul><li><strong>hub 지표</strong>: 가장 많이 추천된 상위 N개 상품이 전체 추천에서 차지하는 비율. 소수 상품에 추천이 집중될수록 높아집니다.</li><li><strong>과노출 상품</strong>: 노출 점유가 인기 점유의 10배를 넘는 상품. 위 다섯 상품이 여기에 해당합니다.</li></ul><h3>Hubness</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mQ_cK5sYsi0-DdU71k3MqA.png" /><figcaption>hub: 많은 점의 Nearest neighbor로 반복 선택되는 점 (Radovanović et al., 2010)</figcaption></figure><p>100명의 취향에 가장 가까운 음식을 고르면 가장 인기 있는 음식이 아니라 평균에 가까운 무난한 음식이 선택됩니다. 이 현상이 hubness이며 추천에서는 유저가 누구든 상단에 반복 노출되는 상품을 hub라고 부릅니다.</p><p>hubness는 인기 편향과 다른 문제입니다. 인기 편향은 많이 팔린 상품이 더 자주 추천되는 데이터의 성질이라면 hubness는 벡터 공간에서 모두의 평균 가까이에 놓였다는 위치의 성질입니다. 뒤에서 보겠지만 인기 상품 점수를 낮춰도 hub는 남아 있었습니다.</p><h3>모델: Multi-interest (MINER)</h3><p>Two-Tower 모델은 유저를 벡터 하나로 표현하기 때문에 러닝화, 캠핑, 피규어를 번갈아 보는 유저라면 세 관심사가 평균으로 섞여 어느 관심사에도 맞지 않는 상품이 추천됩니다. 이를 풀기 위해 유저 history에서 interest 벡터를 여러 개 추출하는 multi-interest 구조를 도입했고 그 중 <a href="https://arxiv.org/abs/2202.03532">MINER</a> 논문을 선정하였습니다.</p><p>interest끼리 비슷한 벡터로 수렴하는 interest collapse를 막는 disagreement regularization이 구조 안에 들어 있다는 점이 선택 이유였습니다. 논문에서 뉴스 추천을 상품 추천에 맞게 수정해서 적용했습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rQMqw6J1E96s0lpOBG8gbQ.png" /><figcaption><em>적용 모델 구조</em></figcaption></figure><p>history(유저가 최근 본 상품, 최대 50개)는 history encoder를 거친 뒤 학습되는 쿼리 벡터(context code) 4개의 attention을 통해 interest 벡터 4개가 됩니다.</p><p>점수는 가장 최근 상품 시점의 상태(last state)와의 유사도, 그리고 interest 4개와의 유사도 중 최댓값의 가중합으로 계산합니다.</p><pre># Multi-interest 점수 계산 Pseudo 코드<br>h = history_encoder(history_items)          # Transformer, 시간 간격 feature 포함<br>interests = [attn(c_k, h) for c_k in context_codes]  # 학습되는 쿼리 벡터 4개<br>last = h[-1]                                 # 가장 최근 상태<br><br>def score(item):<br>    v = item_encoder(item)<br>    interest_score = max(cos(z, v) for z in interests)   # 4개 중 최댓값<br>    return w_int * interest_score + w_last * cos(last, v)</pre><h3>가설: 점수는 두 성분의 합</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1ykYQs8H8HAWfVT7kICKuQ.png" /><figcaption>score(u, i) = 유저 무관 성분 + 유저 의존 성분</figcaption></figure><p>Hubness 문제를 풀기 위해 추천 점수를 두 성분으로 나눠 보는 가설을 세웠습니다.</p><p>유저 의존 성분은 유저마다 다른 결과값을 가지고 유저와 상품간 고유 정보를 가진 성분으로, 유저 무관 성분은 누구에게나 똑같은 정보라고 정의하였습니다.</p><p>유저 무관 성분은 상품마다 정해지는 값이라 이 값이 커질 수록 특정 상품들이 더욱더 상단에 많이 보여지게 될 것이라고 생각했습니다.</p><p>이렇게 생각한 근거는 세 가지였습니다.</p><ol><li><strong>지면 차이</strong>: 같은 모델이지만 후보가 전체 상품인 지면에서는 hub가 드물었고 후보가 인기 상위 3,000개인 인기 상품 목록에서만 두드러졌습니다.</li><li><strong>데모 관찰</strong>: 모델을 테스트해 볼 수 있는 데모페이지에서 history를 여러번 바꿔도 늘 맥락과 상관없이 이따금씩 공통적으로 추천하는 상품들이 있었습니다.</li><li><strong>인기 편향과 다른 현상</strong>: 인기 상품 노출을 조절하는 계수를 여러 값으로 바꿔도 특이한 상품은 남았습니다.</li></ol><p>가설이 맞다면 두 성분을 따로 다루는 일종의 분할 정복으로 접근해보았습니다.</p><ul><li><strong>전략 1. 유저 무관 성분 낮추기</strong></li><li><strong>전략 2. 유저 의존 성분 높이기</strong></li><li><strong>전략 3. 두 성분을 지표가 보게 하기</strong></li></ul><p>전략 3이 필요한 이유는 지표가 두 성분을 보지 못하면 앞의 두 전략이 효과가 있었는지 확인할 수 없기 때문입니다.</p><h3>전략 1. 유저 무관 성분 낮추기</h3><p>먼저 “인기 상품 후보에서는 유저 무관 성분이 커진다”는 가설을 세 가지로 나눠 검증했습니다.</p><h4><strong>검증 1. 후보 집합이 얼마나 평균 방향에 몰려 있는가</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sTOCIyFJljIJ-KOzy0vg8A.png" /><figcaption>측정에 조치 전 모델(3일 치 데이터로 학습)과 실제 유저 2,000명을 사용</figcaption></figure><p>먼저 후보집합에서 유저 무관 성분이 있는지 확인하기 위해 인기 상품 목록의 후보 상품과 유저 코사인 유사도를 구하고, 전체 상품 후보와 유저 코사인 유사도를 구해봤습니다. 전자는 유사도 +0.36이었고 후자에서는−0.18이었습니다. 즉 인기 상품들은 유저에게 유사도가 높은 상품군이고 더 평균 방향에 모여있다고 생각하였습니다.</p><h4><strong>검증 2. interest들이 얼마나 효과적으로 사용중인가</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NInSb0Btc18b-qQibjVbJw.png" /><figcaption>상위 20개 상품의 점수를 결정한 interest 비율</figcaption></figure><p>multi interest 목적에 맞게 학습되었다면 추천 결과에 각 interest가 고르게 관여하는게 이상적입니다.</p><p>하지만 retrieval과 rerank 상황에서 interest 관여 비율을 측정해보았을때 retrieval에서는 38.5%, rerank에서는 52.2%를 차지하고 있었습니다.</p><p>즉, rerank에서는 순위의 과반이 interest 한개에 의존한다고 해석할 수 있습니다. 유저 의존 성분이 순위를 정하지 못하고 무관 성분이 정하고 있다고 봤습니다. 전체 상품 후보에서는 같은 쏠림이 없었기 때문에 후보집합과 Hubness가 결합하여 문제가 증폭되었다고 판단할 수 있었습니다.</p><h4><strong>검증 3. interest 자체에 유저 무관 성분이 있는가?</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FvfWM4jqiTDiDNpN0c3RFg.png" /><figcaption>history를 랜덤으로 바꿔 뽑은 interest 벡터의 평균 길이. 입력과 무관할수록 1에 가까움</figcaption></figure><p>interest 자체에 무관 성분이 있는지 확인하기 위하여 history를 랜덤으로 바꿔 가며 interest 벡터를 여러 번 추출한 뒤 평균 벡터의 길이를 쟀습니다. L2 정규화된 벡터는 길이가 1이기 때문에 여러 방향의 벡터합을 하면 방향 상쇄되어 0에 가까워 집니다.</p><p>실측결과 최소 0.36에서 최대 0.51이 나왔습니다. 즉 유저 history와 무관하게 유지되는 성분이 모든 interest에 뚜렷이 있었고 유저 무관 성분이 interest 벡터 자체에 들어 있다고 판단했습니다.</p><p>검증 1~3의 결과가 모두 가설과 맞았으므로 조치는 유저 무관 성분을 측정해서 빼는 방향으로 정했습니다.</p><h4><strong>조치 1. Centering: 서빙에서 유저 무관 성분 차감</strong></h4><p>유저를 전부 평균 내면 개인 편차는 상쇄되고 무관 성분만 남습니다. 그래서 학습이 끝난 뒤 전체 유저 history로 배치 추론을 실행해 상품별 평균 점수를 구해 두고 서빙할 때 이 값을 차감합니다. 모델을 다시 학습할 필요 없이 서빙 단계에서만 처리하는 방식입니다.</p><p>다만 상품별 평균 점수를 그대로 빼면 인기 상품까지 함께 사라집니다. 이를 막기 위해 유저 무관 성분을 둘로 나눴습니다.</p><blockquote>유저 무관 성분 = 인기 성분 + 과노출 성분</blockquote><p>상품의 인기도를 학습 데이터에서 frequency로 사용하였고, 구간을 200개로 나누었습니다. 상품별로 속하는 구간의 상품들의 점수의 중앙값을 구해 <strong>인기 성분</strong>을 계산하였습니다. 그리고 자신의 점수와 중앙값의 차이를 인기로 설명되지 않는 <strong>과노출 성분</strong>으로 봅니다. 각 성분에 계수를 따로 두고 오프라인 격자 실험으로 값을 정했습니다. 과노출 성분은 retrieval과 rerank 모두에서 전부 빼고(계수 1.0) 인기 성분은 후보가 이미 인기 상품인 rerank에서만 절반을 뺍니다(인기 계수 0.5, retrieval은 0).</p><pre># Centering Pseudo 코드 (학습 후 1회 계산, 서빙 시 차감)<br>m = mean_over_users(score(u, i) for u in user_sample)      # 상품별 평균 점수<br>fit = median_by_popularity_bin(m, bins=200)                # 인기 구간별 중앙값<br>r = m - fit                                                # 인기로 설명되지 않는 잔차<br><br>def centered_score(u, i, residual_coef, popularity_coef):<br>    return score(u, i) - residual_coef * max(r[i], 0) - popularity_coef * fit[i]</pre><p>NLP에서 hubness를 줄이려고 제안된 <a href="https://aclanthology.org/D13-1058.pdf">Centering</a>을 추천 서빙 후처리로 옮긴 방법입니다.</p><h4>조치 2. Bias 분리: 학습에서 유저 무관 성분을 분리</h4><p>Centering은 서빙에서 빼는 것이라 모델은 여전히 유저 무관 성분을 배웁니다. Two-Tower 글에서 소개한 logQ correction은 이미 적용하고 있었지만 logQ는 샘플링 빈도로 설명되는 편향만 보정하기 때문에 빈도로 설명되지 않는 유저 무관 클릭 성향은 그대로 남습니다.</p><p>그래서 <a href="https://arxiv.org/abs/2010.15363">MACR</a>의 item branch 아이디어를 빌려 왔습니다. 상품별 스칼라 파라미터 b(i)를 하나 두고 학습할 때는 로짓에 더했다가 추론할 때는 빼는 구조입니다. 학습 중에 b(i)가 유저와 무관하게 클릭되는 성향을 흡수되게 하려는 의도였습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bdEJ6eZ6GgbVyY8NEqPC6g.png" /><figcaption>학습: logit = score − log q(i) + b(i)</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JKlyzQrPTPSpqa28NoRHcQ.png" /><figcaption>추론: score만 사용. b(i) 제거</figcaption></figure><pre># MACR item branch Pseudo 코드<br>item_bias = nn.Embedding(num_items, 1)   # zero-init<br><br>def train_logits(u, items):<br>    return scores(u, items) / T - log_q(items) + item_bias(items).squeeze(-1)<br><br>def serve_scores(u, items):<br>    return scores(u, items)               # item_bias 미포함</pre><h4><strong>결과 1. 오프라인 지표 변화</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*RX6CUFJBxwImY0llcRjDPw.png" /><figcaption><em>hub 지표 = 고정 유저 패널에서 가장 많이 추천된 상위 N개 상품의 점유율, 과노출 상품 수 = 노출 점유가 인기 점유의 10배를 넘는 상품 수</em></figcaption></figure><blockquote>centering만 적용시 hub 지표 −64%, 과노출 상품 수 −73%, recall −3%</blockquote><blockquote>bias 분리만 적용시 −52%, −15%, recall −1%</blockquote><blockquote>bias 분리 후 b(i)를 추론에 다시 더할경우 +16%, +3%, recall +1%</blockquote><blockquote>둘을 결합하였을 때 −66%, −89%, recall -4%</blockquote><p>hub 지표와 과노출 상품수 두 지표는 모두 낮을 수록 좋습니다. 조치 1, 2 모두 두 지표를 낮추는데 효과적이었고, 둘을 결합하였을때 효과가 가장 좋았고 이를 채택하였습니다. 단 bias를 분리 학습하고 추론할 때 다시 더할경우 두 지표가 상승하였습니다.</p><p>하지만 의도와 다르게 recall이 4%나 하락하였습니다. 이는 유저 무관 성분을 빼면 모두에게 조금씩 맞는 인기 상품(click baiting)이 덜 노출되는데 recall은 실제 클릭을 맞혔는지로 측정하고 그 클릭은 인기 상품에 몰려 있기 때문이라고 판단했습니다.</p><h4><strong>결과 2. 온라인 지표 변화</strong></h4><p>이를 바탕으로 A/B 테스트를 진행했습니다.</p><p>과노출 상품은 모두 제거되었고, 해당 상품들은 대부분 구매가 거의 없던 상품이었습니다. 노출 상위 100개 상품의 노출 점유율은 62%나 줄었습니다.그리고 노출 고유상품 수는 25% 증가하였습니다.</p><p>반면에 오프라인 테스트에서도 관찰된 것과 유사하게 유저당 클릭이 -5.1% 감소하였습니다. 구매 가드레일의 비열등성을 확인하였고 노출 감소 상품들이 대부분 구매와 무관하였기 때문에 실험군 롤아웃을 결정하였습니다.</p><h3>전략 2. 유저 의존 성분 높이기</h3><p>전략 1에서는 유저 무관 성분을 줄였는데요. interest가 4개나 되는데도 이런 문제가 발생한 원인과 유저 의존 성분을 높이기 위한 방법을 찾아보겠습니다.</p><p>여기서는 “multi-interest 구조에서 interest가 history의 서로 다른 관심사를 나눠 담으면 유저 의존 성분이 커진다”는 가설을 세웠습니다. 목표는 interest 간 유사도는 최소화하면서 recall과 온라인 목표 지표는 최대화하는 것이었습니다.</p><h4><strong>시도 1. cosine 규제 강화</strong></h4><p>첫번째로 interest를 뚜렷하게 구분하게 하여 의존 성분을 높여 보는 전략을 시도해보았습니다. interest 벡터끼리 비슷하면 페널티를 주는 cosine 규제(disagreement regularization)의 가중치를 100배로 높였습니다.</p><p>그 결과 interest 간 코사인 유사도는 0.65 → 0.03으로 매우 낮아져 거의 완전히 다른 벡터로 구분이 되었습니다.</p><p>하지만 recall이 25%로 대폭 하락하였고 추천 상품 10개를 가장 많이 결정한 interest 점유 비중이 41%에서 89%로 두배 이상 증가하였습니다. 결국 이 방법은 기각했습니다.</p><p>그 원인을 확인해 보았고 interest 점수를 합치는 방식인 max aggregation에 있었습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EzSf6wQ_pC5EGOm4OyHXbA.png" /><figcaption>max aggregation. interest 4개가 서로 달라도 가장 강한 interest 하나의 연관 상품이 상단을 차지</figcaption></figure><p>최종 점수는 상품마다 interest 4개 중 최댓값입니다. 따라서 interest가 러닝화, 캠핑, 피규어, 의류로 잘 나뉘어 있더라도 점수순으로 상위 N개를 선택하면 가장 강한 interest의 연관 상품이 상단을 모두 차지합니다. cosine 규제로 벡터 사이를 크게 벌리자 interest 하나의 점수가 커지면서 그 interest가 상위 결과를 대부분 차지했습니다.</p><p>후보마다 attention으로 interest를 결합하는 candidate-aware aggregation도 시도했지만 지표에서 이점이 없어 제거했습니다.</p><p>cosine 규제를 강화하는 대신 카테고리를 나누는 쪽으로 방향을 바꿨습니다.</p><h4><strong>시도 2. 카테고리 규제 추가</strong></h4><p>cosine 규제에서 interest간 유사도가 낮아졌지만, 이것이 interest가 의도대로 잘 분리되었다고 보긴 어려웠습니다. 두번째 시도로는 interest마다 다른 카테고리를 보도록 interest 쌍의 카테고리 분포가 겹치면 페널티를 주는 규제를 추가했습니다.</p><p>그 결과 interest간 코사인 유사도는 0.65에서 0.52로 감소, 상위 10개를 가장 많이 결정한 interest의 점유율은 41%에서 28%로 크게 감소하였습니다. 추가적으로 Multi interest 모델 목적인 카테고리 커버리지는 0.61에서 0.77로 27% 증가하였습니다.</p><p>반면 recall은 -2%로 소폭 하락 하였습니다. recall은 소폭 하락했지만 interest가 카테고리별로 잘 나뉘고 다른 지표들이 상승하여 유저 의존 성분을 높이는데 유리하다 생각하여 적용하였습니다.</p><h4><strong>시도 3. 추천 결과 다양성 후처리</strong></h4><p>전략 1과 2를 적용한 모델로 <em>무한 스크롤 피드</em>에서 A/B Test를 진행하였습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rRes_lcAhLWaO_9pq9JtJw.png" /><figcaption>무한 스크롤 피드 A/B. 다양성 후처리 없음 vs 있음 (기존 모델 대비)</figcaption></figure><p>두번의 실험을 진행했고, 옅은 회색이 첫번째 실험, 진한 회색이 두번째 실험입니다. 첫번째 실험에서는 후처리 없이 모델 결과를 그대로 사용하였습니다. 그 결과 클릭지표가 매우 많이 떨어졌습니다. 오프라인 지표에서 recall은 -2% 남짓 떨어진 것에 비하면 온라인 지표가 매우 나쁘게 나와 원인을 분석해보았습니다.</p><p>확인 결과 대조군에는 추천 결과에 카테고리 다양성 후처리가 있었고 실험군에서는 없었습니다. 동일한 후처리를 추가하고 모델의 개선 사항에 대해서 다시 실험하였고, 상위 10개 상품의 클릭 +18%, 유저당 클릭 +29%를 기록했습니다. 오프라인으로 유저 의존 성분을 측정해 가설을 검증하지는 못했지만 온라인 실험에서 목표 지표인 클릭을 크게 회복하고 대조군 대비 크게 상회한 것을 확인하였습니다.</p><p>정리하면 벡터 사이를 벌리는 것만으로는 부족했고 interest별 카테고리 분리와 다양성 후처리가 함께 필요했습니다. 다만 후처리 없는 실험의 지표 하락을 당시 오프라인 지표는 미리 보여 주지 못했습니다. 이는 전략 3에서 다룰 지표의 문제입니다.</p><h3>전략 3. 두 성분을 지표가 보게 하기</h3><p>앞의 결함이 있었는데도 A/B Test를 진행했던 이유는 지표에서 결함을 보지 못했기 때문입니다. 오프라인 지표, 온라인 목표지표, 지면지표 세가지에서 문제점을 확인해보았습니다.</p><h4><strong>분석 1. recall로 Hubness를 판단할 수 있을까</strong></h4><p>여러 상황 테스트중 input feature를 비워 강제로 interest를 collapse 시켰을 때 interest간 겹침 비중이 2.6배나 높아졌는데 recall은 11%나 높아졌습니다.</p><p>collapse는 유저 의존 성분이 하나로 줄어 hub가 드러나는 조건입니다. 하지만 CTR Prediction 과제에서는 평균 벡터 하나로 예측하는 쪽이 유리하기 때문에 단순히 recall만 측정했을때 지표가 올랐고 이를 성과로 판단하게 됩니다.</p><h4><strong>분석 2. 클릭으로 </strong>Hubness를 판단할 수 있을까</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IEno-n7Jevm0rpx2mBhp5w.png" /><figcaption>과노출 상품의 클릭률과 구매 전환율 (전체 평균 대비 배수)</figcaption></figure><p>Centering과 Bias를 분리한 첫번째 전략으로 A/B Test 하였을 때 클릭은 -5% 하락하였으나 실험군으로 롤아웃 하였습니다. 이 근거는 과노출 상품 측정 지표가 있었기 때문입니다. 제거된 과노출 상품은 클릭은 높지만 구매전환이 거의 없는 특징이 있었기 때문에 단순히 클릭만 봤다면 과노출 상품을 유지하거나 오히려 높이는 방향으로 의사결정을 하였을 것입니다.</p><h4><strong>분석 3. 지면 지표는 지면 설계를 반영할 수 없다</strong></h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tgsUtdsep14x64inrncl4g.png" /><figcaption><em>왼쪽부터 카테고리 추천, 무한 스크롤 피드, 인기 상품 목록</em></figcaption></figure><p>Hubness 발견 전 해당 모델을 <em>카테고리 추천 지면</em>에 적용하였고 실험결과 클릭 +6.6% 상승하였습니다. 클릭 상승을 바탕으로 무한 스크롤 피드에 그대로 적용하였고 이전에 서술 하였던 것 처럼 상위 10개 상품 클릭이 23% 하락하였습니다.</p><p>카테고리 추천 지면에서는 카테고리별로 1개만 노출하는 규칙 자체가 다양성을 만들어 주기 때문에 실험 결과가 증명한 것은 interest의 다양성이 아니라 카테고리 안의 정확도였습니다. 따라서 실험 전 지면에 적용된 후처리 방식을 확인해 지면 설계의 기여와 모델의 기여를 나눠서 봐야한다고 알게 되었습니다.</p><h4><strong>조치: 평가 체계 변경</strong></h4><p>위 분석들을 바탕으로 평가지표를 개선하였고 다음과 같습니다.</p><p>오프라인 지표에는 노출 분포 지표(hub 지표, 상위 100개 노출 점유, unique 노출 상품 수)를 추가했습니다.</p><p>온라인 지표에는 클릭에 더해 과노출이 나빠지지 않아야 한다는 비열등성 조건을 두고 판단 기준은 실험 전에 확정하도록 했습니다.</p><p>그리고 새 지면에 기존 모델을 반영할 때는 지면의 후처리 규칙을 먼저 확인하고 모델의 다양성은 분포 지표로 따로 평가하도록 했습니다.</p><p>지표 하나로 판단하면 결함이 개선으로 읽히므로 정확도 지표와 분포 지표를 함께 봐야 합니다.</p><h3>남은 과제</h3><p>문제를 해결하는 과정중에서 해결하지 못하고 아직 남은과제는 세가지 정도를 생각해보았습니다.</p><p>첫번째, 후보집합 변경</p><ul><li>인기 상품 후보의 개수를 조절하거나 상품 특성군을 나누어 후보집합을 앙상블 하는 방식으로 변경해보면 다양성 확보와 인기도를 같이 증가시킬 수 있을 것 같습니다.</li></ul><p>두번째, Aggregation 방법 변경</p><ul><li>기존에 aggregation 방식으로 candidate-aware aggregation, mean, max, round robin 등을 테스트해보았으나 속도가 빠르고 지표상 안정적이었던 max aggregation 방식을 변경해볼 수 있을 것 같습니다.</li><li>현재 사용중인 aggregation 방식을 클릭이나 구매를 타겟하여 변경해 볼 수 있을 것 같습니다.</li></ul><p>세번째, history 부족 유저 대응</p><ul><li>현재는 히스토리가 적은 유저나 비 로그인 유저의 경우 비지니스로직으로 대응중이지만 이를 모델에서 대응하면 해당 유저들에게 더 효과적인 추천이 가능할 것 같습니다.</li></ul><h3>결론</h3><p>한 줄로 요약하면 같은 상품이 모두에게 노출된 원인은 후보 집합, 모델 구조, 평가 지표 세 가지였습니다.</p><ul><li><strong>전략 1</strong>: centering과 bias 분리로 과노출 상품을 모두 제거했고 unique 노출 상품 수가 25% 늘었습니다.</li><li><strong>전략 2</strong>: cosine 규제는 효과가 없었고 카테고리 규제와 다양성 후처리는 효과가 있었습니다.</li><li><strong>전략 3</strong>: recall, 클릭, 지면 지표 모두 두 성분의 변화를 보지 못해 분포 지표를 추가하고 판단 기준을 실험 전에 확정하도록 바꿨습니다.</li></ul><p>비슷한 모델을 운영하신다면 바로 해 볼 수 있는 점검 항목을 남깁니다.</p><ol><li>새 지면에 기존 모델을 적용할 때 후보와 유저 평균 방향의 코사인 분포를 확인합니다. 양수에 몰려 있으면 지면별 보정 계수를 분리합니다.</li><li>모델 채택 기준에 노출 분포 지표(상위 N개 노출 점유, unique 노출 상품 수)를 추가합니다.</li><li>온라인 실험에서는 클릭과 분포 지표를 함께 보고 구매는 마진과 표본 크기를 미리 정한 가드레일로 운영합니다.</li><li>multi-interest 모델이라면 history를 랜덤으로 바꿔 interest별 입력 불변성(평균 벡터 길이)을 확인합니다.</li></ol><p>KREAM은 사용자에게 더 나은 탐색 경험을 제공하기 위하여 흥미로우면서도 복잡한 기술적 문제들을 해결해나가고 있습니다. 이러한 여정에 함께할 동료를 항상 찾고 있으니, 관심 있으신 분들의 많은 참여 부탁드립니다!</p><p><a href="https://recruit.kreamcorp.com/rcrt/list.do"><strong>KREAM 채용 페이지</strong></a></p><h3>참고 자료</h3><ul><li><a href="https://aclanthology.org/2022.findings-acl.29.pdf">Li et al. MINER: Multi-Interest Matching Network for News Recommendation. Findings of ACL 2022</a></li><li><a href="https://www.jmlr.org/papers/v11/radovanovic10a.html">Radovanović, Nanopoulos, Ivanović. Hubs in Space: Popular Nearest Neighbors in High-Dimensional Data. JMLR 2010</a></li><li><a href="https://aclanthology.org/D13-1062/">Suzuki et al. Centering Similarity Measures to Reduce Hubs. EMNLP 2013</a></li><li><a href="https://jmlr.org/papers/v13/schnitzer12a.html">Wei et al. Model-Agnostic Counterfactual Reasoning for Eliminating Popularity Bias in Recommender System (MACR). KDD 2021</a></li><li><a href="https://arxiv.org/abs/2105.06067">Zhang et al. Causal Intervention for Leveraging Popularity Bias in Recommendation (PDA). SIGIR 2021</a></li><li><a href="https://arxiv.org/abs/1602.05352">Schnabel et al. Recommendations as Treatments: Debiasing Learning and Evaluation (IPS). ICML 2016</a></li><li><a href="https://arxiv.org/abs/2005.09347">Cen et al. Controllable Multi-Interest Framework for Recommendation (ComiRec). KDD 2020</a></li><li><a href="https://arxiv.org/abs/1904.08030">Li et al. Multi-Interest Network with Dynamic Routing for Recommendation at Tmall (MIND). CIKM 2019</a></li><li><a href="https://research.google/pubs/sampling-bias-corrected-neural-modeling-for-large-corpus-item-recommendations/">Yi et al. Sampling-Bias-Corrected Neural Modeling for Large Corpus Item Recommendations. RecSys 2019</a></li></ul><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F8D0CaQrUgCU%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D8D0CaQrUgCU&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F8D0CaQrUgCU%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/eca689d494e9be6c0a73c69344adc0eb/href">https://medium.com/media/eca689d494e9be6c0a73c69344adc0eb/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=27f79d039d5d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/kream-%EA%B8%B0%EC%88%A0-%EB%B8%94%EB%A1%9C%EA%B7%B8/%EB%94%B8%EA%B9%8D%EC%9C%BC%EB%A1%9C-%EC%95%88%EB%90%98%EB%8A%94-multi-interest-%EB%AA%A8%EB%8D%B8-%EA%B0%9C%EB%B0%9C%EA%B8%B0-27f79d039d5d">딸깍으로 안되는 Multi-interest 모델 개발기</a> was originally published in <a href="https://medium.com/kream-%EA%B8%B0%EC%88%A0-%EB%B8%94%EB%A1%9C%EA%B7%B8">KREAM 기술 블로그</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[2025회고 및 2026목표]]></title>
            <link>https://chrisjune-13837.medium.com/2025%ED%9A%8C%EA%B3%A0-%EB%B0%8F-2026%EB%AA%A9%ED%91%9C-e463328995fb?source=rss-e74406582b08------2</link>
            <guid isPermaLink="false">https://medium.com/p/e463328995fb</guid>
            <category><![CDATA[2026]]></category>
            <dc:creator><![CDATA[chrisjune]]></dc:creator>
            <pubDate>Wed, 31 Dec 2025 15:44:45 GMT</pubDate>
            <atom:updated>2025-12-31T15:44:45.278Z</atom:updated>
            <content:encoded><![CDATA[<p>아이들을 키우고 현생을 살기에 바쁘다는 핑계로 몇년째 회고를 미루고 미루다 오랜만에 회고를 작성해본다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*AAemkXQw9NWGPWuowbpX8Q.png" /></figure><h4>2025년 감사 제목</h4><p>자녀 성장 &amp; 육아</p><ul><li>첫째 시원이 성장: 기저귀 떼기 성공, 정서적으로 안정되어지고 지시수행 능력이 높아짐</li><li>둘째 주원이 성장: 말문이 트이고, 시원이와 같은 어린이집을 등원할 수 있게 됨</li><li>주원이가 장중첩증을 걸렸었는데 와이프의 판단으로 빠르게 응급시술을 받을 수 있게 되었음</li><li>부모로서 태도: 사모님의 조언을 통해 아이들을 더 따뜻한 시선으로 볼 수 있게 됨</li><li>깨달음: 아이들의 잠재력과 가능성을 믿어야 조금이라도 할 수 있게 됨을 깨닫고 그동안 조바심과 의구심을 많이 품었던 자신을 반성하게됨</li></ul><p>배우자 &amp; 가족</p><ul><li>아내의 비상: 퀀트투자자로서 와이프가 일을 성공적으로 시작하게 되었고, 사업까지 구상할 수 있게 됨</li><li>관계 회복: 오랫동안 막혔던 가족간의 관계가 회복됨</li><li>가족 행사: 동생이 결혼하게 되었고 신혼 여행을 지원해줄 수 있게됨. 조카가 중학교까지 잘 마무리할 수 있게됨</li><li>부모님: 칠순 선물을 드릴 수 있게됨</li></ul><p>신앙 &amp; 교회</p><ul><li>교회 정착: 교회를 잘 옮겨 믿음이 견고해지고, 좋은 교회 가족이 생김</li><li>봉사: 나는 점심 식사를 만드는 일, 아내는 영유아 교사로서 봉사할 수 있게 됨</li></ul><p>커리어</p><ul><li>업무: 새로운 동료들이 생겨 팀이 더욱 단단해짐.</li><li>학습: 스터디 (외부논문, 동료논문, ML초급반) 지속</li></ul><p>라이프</p><ul><li>건강 회복: 축농증 재수술이 성공적으로 끝남.</li><li>운동: 매일은 아니지만 새벽 운동을 꾸준히 진행</li><li>여행: 엄마와 처제의 도움으로 발리 여행을 다녀옴</li><li>친구: 친한 친구들의 결혼과 출산소식, 친구들에게 웨딩 플래너를 잘 소개해 줄 수 있었음</li></ul><h4>올해의 목표</h4><p>영</p><ul><li>말씀 중심의 삶: 성령의 감동으로 말씀을 묵상하고, 그 말씀대로 살아가는 한 해 만들기</li><li>루틴: 운동전 새벽 시간에 묵상 &amp; 기도</li><li>디지털 디톡스: 단순 재미를 위한 영상 &amp; 게임 최소화, 대신 소설 등 책 읽기 집중. 월 1권</li></ul><p>육</p><ul><li>주 6회 운동 루틴: 3회 야외러닝 + 3회 웨이트</li><li>연말에 물구나무 푸시업 성공하기</li></ul><p>가정</p><ul><li>자녀케어: 9시정각 등원, 몸으로 20분 + 책으로 20분 놀아주기</li><li>아내의 고민과 이야기에 관심을 가지고 20분 경청하기</li><li>이사 잘 마무리하기</li></ul><p>업무</p><ul><li>데일리 루틴: 작년 8월부터 매일 작성하고 있는 daily todo txt 파일 잘 관리하기</li><li>자기계발: 매일 20분 공부하고 정리</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e463328995fb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[How to Fix LightGBM Installation Errors on Linux]]></title>
            <link>https://chrisjune-13837.medium.com/lightgbm-got-an-error-on-installing-lightgbm-on-linux-9e2f9837e059?source=rss-e74406582b08------2</link>
            <guid isPermaLink="false">https://medium.com/p/9e2f9837e059</guid>
            <category><![CDATA[mls]]></category>
            <category><![CDATA[lightgbm]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[chrisjune]]></dc:creator>
            <pubDate>Fri, 29 Aug 2025 05:25:40 GMT</pubDate>
            <atom:updated>2025-09-11T06:34:20.765Z</atom:updated>
            <content:encoded><![CDATA[<p>I recently encountered several errors while trying to build LightGBM from source on a CentOS 7 system. The initial build attempt failed with the following C++17 compiler error</p><p>The error message Target &quot;lightgbm&quot; requires the language dialect &quot;CXX17&quot; clearly indicates that the system&#39;s default C++ compiler is too old and does not support the required C++17 standard.</p><h3>Summary: The Complete Solution</h3><p>Here is the complete sequence of commands to successfully build LightGBM on a CentOS 7 EOL system</p><p>Prerequisite, install c++ complier.</p><pre>&gt; sudo yum install -y centos-release-scl<br>&gt; sudo sed -i &#39;s/mirrorlist/#mirrorlist/g&#39; /etc/yum.repos.d/CentOS-*<br>&gt; sudo sed -i &#39;s|# baseurl=http://mirror.centos.org|baseurl=http://vault.centos.org|g&#39; /etc/yum.repos.d/CentOS-*<br>&gt; sudo sed -i &#39;s|mirror.centos.org|vault.centos.org|g&#39; /etc/yum.repos.d/CentOS-SCLo-scl.repo<br>&gt; sudo yum groupinstall &quot;Development Tools&quot; -y<br><br>&gt; sudo yum remove cmake<br>&gt; sudo yum install cmake -y<br>&gt; sudo yum install -y devtoolset-11-gcc-c++<br>&gt; sudo enable devtoolset-11 bash<br>&gt; scl enable devtoolset-11 bash<br></pre><p>Let’s build LightGBM.</p><pre>&gt; git clone --recursive https://github.com/microsoft/LightGBM<br>&gt; cd LightGBM<br><br>&gt; rm -rf build # Delete build directory when you already tried to build it.<br>&gt; cmake -B build -S .<br>&gt; cmake --build build -j4</pre><p>Check whether the package is installed well or not.</p><pre>root@ranking-data-retrieve-0 LightGBM][c3s-env]$ /home1/jovyan/LightGBM/lightgbm<br>[LightGBM] [Info] Finished loading parameters<br>[LightGBM] [Fatal] No training/prediction data, application quit<br>Met Exceptions:<br>No training/prediction data, application quit</pre><p>Debian / Ubuntu version</p><p>Prerequisite</p><pre>&gt; sudo apt-get update<br>&gt; sudo apt-get install -y build-essential g++-11 git cmake</pre><p>Build</p><pre>git clone --recursive https://github.com/microsoft/LightGBM<br>cd LightGBM<br><br>rm -rf build<br>cmake -D CMAKE_CXX_COMPILER=g++-11 -D CMAKE_C_COMPILER=gcc-11 -B build -S .<br>cmake --build build -j4</pre><p>🎉 It’s done! 🎉</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9e2f9837e059" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[밑바닥에서 개선한 추천시스템 with Two-Tower Model]]></title>
            <link>https://medium.com/kream-%EA%B8%B0%EC%88%A0-%EB%B8%94%EB%A1%9C%EA%B7%B8/%EB%B0%91%EB%B0%94%EB%8B%A5%EC%97%90%EC%84%9C-%EA%B0%9C%EC%84%A0%ED%95%9C-%EC%B6%94%EC%B2%9C%EC%8B%9C%EC%8A%A4%ED%85%9C-with-two-tower-model-e940817af2bb?source=rss-e74406582b08------2</link>
            <guid isPermaLink="false">https://medium.com/p/e940817af2bb</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[recommender-systems]]></category>
            <category><![CDATA[two-tower]]></category>
            <category><![CDATA[machine]]></category>
            <category><![CDATA[deep-learning]]></category>
            <dc:creator><![CDATA[chrisjune]]></dc:creator>
            <pubDate>Wed, 06 Aug 2025 07:49:50 GMT</pubDate>
            <atom:updated>2025-08-06T08:18:52.025Z</atom:updated>
            <content:encoded><![CDATA[<h3>추천시스템 개선을 위한 Two-Tower 모델 적용기</h3><p>안녕하세요! KREAM의 추천서비스 엔지니어 최준영입니다.</p><p>KREAM은 리셀 서비스에서 시작하여 테크, 라이프스타일로 확장하며 개인화된 추천 시스템 구축에 힘쓰고 있습니다. 이 글에서는 Matrix Factorization에서 Two-Tower 모델로의 전환 과정과 핵심 구현 사항을 공유합니다.</p><h3>추천시스템의 진화 과정</h3><h3>초기: 단순한 인기상품 추천</h3><p>이전에는 단순 구매 수량 기반의 인기상품 추천에 머물렀지만, 사용자 장/단기 선호를 반영한 개인화된 추천의 필요성을 느껴 자체 모델 구축으로 전환했습니다.</p><pre># 인기상품 추천 Pseudo 코드<br>def popular_item_recommendation(limit=10):<br>    # 구매 수량 기준으로 상품 정렬<br>    popular_items = db.query(&quot;&quot;&quot;<br>        SELECT item_id, COUNT(*) as purchase_count<br>        FROM purchases <br>        GROUP BY item_id <br>        ORDER BY purchase_count DESC <br>        LIMIT ?<br>    &quot;&quot;&quot;, limit)<br><br>    return popular_items</pre><h3>Matrix Factorization 도입</h3><p><strong>Matrix Factorization(MF)</strong> 모델을 베이스라인으로 활용하며 Kubeflow 기반의 MLOps 파이프라인을 구축했습니다. 이를 통해 효율적인 학습과 서빙 환경을 마련했습니다.</p><p>MF는 사용자와 아이템 간의 상호작용 데이터를 기반으로 잠재 요인을 학습하여 추천을 수행하는 강력한 알고리즘입니다. 하지만 다음과 같은 한계가 있었습니다</p><ul><li>복잡한 상호작용을 포착하는 것은 어려움</li><li>Cold-start 문제를 개선해야 하는 고민이 필요</li></ul><pre># Matrix Factorization Pseudo 코드<br>class MatrixFactorization:<br>    def __init__(self, n_users, n_items, n_factors=50):<br>        self.user_factors = np.random.normal(0, 0.1, (n_users, n_factors))<br>        self.item_factors = np.random.normal(0, 0.1, (n_items, n_factors))<br><br>    def predict(self, user_id, item_id):<br>        # 사용자와 아이템 잠재 벡터의 내적<br>        return np.dot(self.user_factors[user_id], self.item_factors[item_id])<br><br>    def recommend(self, user_id, n_recommendations=10):<br>        # 모든 아이템에 대해 예측 점수 계산<br>        scores = [self.predict(user_id, item_id) for item_id in range(len(self.item_factors))]<br>        return np.argsort(scores)[::-1][:n_recommendations]</pre><h3>Two-Tower Neural Network 도입</h3><p>이러한 한계를 극복하기 위해 <strong>Two-Tower Neural Network</strong> 아키텍처를 도입했습니다.</p><p>2024년 1월부터 모델 개선을 적용한 결과, 사용자 고유 클릭 수가 크게 증가했습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/942/1*PMUP6k1FbaYlr0ebKDKXBg.png" /><figcaption>개선된 모델을 1월 24일 배포한 전 후 특정 구좌의 user unique click count.</figcaption></figure><h3>Two-Stage Architecture: 확장성 문제의 해결</h3><p>서비스 규모의 추천 시스템 구축에서 가장 먼저 직면하는 과제는 <strong>방대한 아이템 코퍼스</strong>입니다. 1천만 개 이상의 아이템이 있는 경우, 모든 아이템을 사용자 쿼리마다 재랭킹하는 것은 현실적으로 불가능합니다.</p><p>이 문제를 해결하기 위한 일반적인 전략이 <strong>Two-stage 패턴</strong>입니다.</p><h3>1단계: 후보 아이템 검색 (Candidate Retrieval)</h3><p>수천만 개의 아이템 풀에서 사용자에게 가장 관련성이 높은 N개(수백~수천 개)의 아이템을 빠르게 필터링합니다. 이 단계에서는 <strong>속도와 커버리지</strong>가 중요합니다.</p><h3>2단계: 랭킹 (Ranking)</h3><p>검색 단계에서 추출된 소수의 후보 아이템들을 더 복잡하고 정교한 모델로 순위를 매기고 최종 추천 목록을 생성합니다. 이 단계에서는 <strong>정확도와 개인화</strong>가 중요합니다.</p><p>저희는 이 두 단계 패턴 중 <strong>후보 아이템 검색 단계</strong>를 효율적으로 수행하기 위해 <strong>Two-Tower Neural Network</strong>를 도입했습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/681/1*6wA3Fs5zN705O8I6gpy1ZA.png" /><figcaption><a href="https://dl.acm.org/doi/pdf/10.1145/2959100.2959190">https://dl.acm.org/doi/pdf/10.1145/2959100.2959190</a></figcaption></figure><h3>Two-Tower Architecture 상세</h3><p><strong>Two-Tower 아키텍처</strong>는 업종과 상관없이 다양한 서비스에서 성공을 거둔 모델입니다. 모델 성능이 안정적이고 서빙 속도가 빠른 장점이 있으며, Youtube, Uber, Baidu 등에서 활용되고 있습니다.</p><h3>아키텍처 구성</h3><p>이 아키텍처의 핵심은 크게 두 가지 인코더로 구성됩니다</p><pre>Query Encoder (사용자) ──┐<br>                       ├─ Dot Product ─ Activation ─ Score<br>Item Encoder (아이템) ───┘</pre><h4>1. 쿼리 인코더 (Query Encoder, 사용자 타워)</h4><p>사용자의 맥락 정보(유저ID, 성별, 나이, 지역, 검색 쿼리)를 입력받아 사용자 임베딩을 학습합니다.</p><h4>2. 아이템 인코더 (Item Encoder, 아이템 타워)</h4><p>후보 아이템의 콘텐츠 특성(아이템ID, 카테고리, 가격, 위치, 선호도)을 입력받아 아이템 임베딩을 학습합니다.</p><h3>상호작용 계산</h3><p>두 인코더의 출력은 <strong>내적(dot product)</strong>을 통해 상호작용하며, 이 값을 SoftMax나 Sigmoid와 같은 활성화 함수에 전달하여 최종 추천 점수를 계산합니다.</p><p>중요한 점은 <strong>두 인코더의 출력 벡터 크기가 동일해야 한다</strong>는 것입니다. 각 인코더는 일반적으로 여러 개의 완전 연결 계층과 비선형 활성화 함수(주로 ReLU)로 구성됩니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/597/1*2IMu-iZ2Zw6dVGemY4jy2Q.png" /><figcaption><a href="https://storage.googleapis.com/gweb-research2023-media/pubtools/6090.pdf">https://storage.googleapis.com/gweb-research2023-media/pubtools/6090.pdf</a></figcaption></figure><h3>모델 구현</h3><ul><li><strong>프레임워크</strong>: 모델프레임 워크는 Tensorflow를 메인으로 사용하였고, Boilerplate code를 줄이기 위해 tensorflow-recommenders(tfrs)라이브러리도 사용하였습니다.</li><li><strong>데이터 처리</strong>: 내부 ETL 파이프라인으로 1차 가공후 모델파이프라인에서 Pandas를 활용해 2차 가공하였습니다.</li></ul><h4>핵심 구현 코드</h4><p>다음은 tensorflow를 사용하여 Two-Tower 모델의 핵심 구조를 구현하는 코드입니다.</p><pre>import tensorflow as tf<br>from typing import Dict, Text<br><br>class TowerModel(tf.keras.Model):<br>    &quot;&quot;&quot;사용자 또는 아이템을 위한 타워 모델의 기본 구조&quot;&quot;&quot;<br>    def __init__(self, vocab_size: int, embedding_dim: int):<br>        super().__init__()<br>        # 1. ID를 입력받아 임베딩 벡터로 변환하는 레이어<br>        self.embedding = tf.keras.layers.Embedding(vocab_size, embedding_dim)<br>        # 2. 임베딩 벡터를 처리할 추가적인 Dense 레이어<br>        self.dense_layers = tf.keras.Sequential([<br>            tf.keras.layers.Dense(128, activation=&#39;relu&#39;),<br>            tf.keras.layers.Dense(embedding_dim)  # 최종 출력은 임베딩 차원과 동일하게<br>        ])<br><br>    def call(self, ids: tf.Tensor) -&gt; tf.Tensor:<br>        # ID -&gt; Embedding Vector -&gt; Dense Layers<br>        embeddings = self.embedding(ids)<br>        return self.dense_layers(embeddings)<br><br>class TwoTowerModel(tf.keras.Model):<br>    &quot;&quot;&quot;User Tower와 Item Tower를 결합하고 학습 로직을 정의하는 모델&quot;&quot;&quot;<br>    def __init__(self, user_tower: TowerModel, item_tower: TowerModel):<br>        super().__init__()<br>        self.user_tower = user_tower<br>        self.item_tower = item_tower<br><br>    def call(self, features: Dict[Text, tf.Tensor]) -&gt; Dict[Text, tf.Tensor]:<br>        # 각 타워를 통과시켜 사용자, 아이템 임베딩을 계산<br>        return {<br>            &quot;user_embedding&quot;: self.user_tower(features[&quot;user_id&quot;]),<br>            &quot;item_embedding&quot;: self.item_tower(features[&quot;item_id&quot;])<br>        }<br><br>    def train_step(self, data: Dict[Text, tf.Tensor]) -&gt; Dict[Text, tf.Tensor]:<br>        # tf.GradientTape를 사용하여 그래디언트를 기록<br>        with tf.GradientTape() as tape:<br>            # 1. 모델의 call 메소드를 통해 user, item 임베딩을 얻음<br>            embeddings = self(data)<br>            user_embeddings = embeddings[&quot;user_embedding&quot;]<br>            item_embeddings = embeddings[&quot;item_embedding&quot;]<br><br>            # 2. In-batch Negative Sampling을 위한 손실 계산<br>            # user와 item 임베딩 간의 내적(dot product)을 통해 유사도 행렬 계산<br>            scores = tf.linalg.matmul(user_embeddings, item_embeddings, transpose_b=True)<br><br>            # 3. Ground Truth (정답) 생성<br>            # 배치 내의 각 user(i)에 대한 정답 item은 동일한 인덱스(i)를 가짐<br>            batch_size = tf.shape(user_embeddings)[0]<br>            labels = tf.range(batch_size, dtype=tf.int64)<br><br>            # 4. Cross-Entropy 손실 계산<br>            loss = self.compiled_loss(labels, scores)<br><br>        # 5. 그래디언트 계산 및 가중치 업데이트<br>        gradients = tape.gradient(loss, self.trainable_variables)<br>        self.optimizer.apply_gradients(zip(gradients, self.trainable_variables))<br><br>        # 6. 메트릭 업데이트 및 결과 반환<br>        self.compiled_metrics.update_state(labels, scores)<br>        return {m.name: m.result() for m in self.metrics}</pre><h3>모델 학습 및 추론</h3><pre># 모델 생성 및 학습<br>num_users = 1000<br>num_items = 5000<br>embedding_dimension = 64<br><br>user_tower = TowerModel(num_users, embedding_dimension)<br>item_tower = TowerModel(num_items, embedding_dimension)<br>model = TwoTowerModel(user_tower, item_tower)<br><br># 모델 컴파일<br>model.compile(<br>    optimizer=tf.keras.optimizers.Adam(learning_rate=1e-3),<br>    loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),<br>    metrics=[&#39;accuracy&#39;]<br>)<br><br># 학습 데이터로 훈련<br>dummy_data = {<br>    &quot;user_id&quot;: tf.constant([1, 2, 3]),<br>    &quot;item_id&quot;: tf.constant([10, 20, 30])<br>}<br><br>loss = model.train_on_batch(dummy_data)<br>print(f&quot;Train loss: {loss}&quot;)</pre><h3>Two Tower 모델 학습의 핵심 기법</h3><h3>In-Batch Sampled SoftMax</h3><p>Two-Tower 모델 학습에는 주로 Binary Cross-Entropy 또는 Categorical Cross-Entropy 손실 함수가 사용됩니다. 저는 <strong>In-Batch Sampled SoftMax</strong> 전략을 활용하여 Categorical Cross-Entropy 손실을 계산합니다.</p><h4>왜 In-Batch Sampled SoftMax인가?</h4><p>실제 환경에서는 후보 아이템 수가 수백만 개에 달할 수 있어, 모든 아이템에 대해 SoftMax를 계산하는 것은 메모리 문제로 사실상 불가능합니다. In-Batch Sampled SoftMax는 현재 미니배치 내의 다른 예시들을 <strong>네거티브 샘플</strong>로 활용하여 전체 데이터셋에서 네거티브를 샘플링하는 자원 소모를 줄여줍니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/731/1*3QwpgqZdmK3VUkuM17DKhw.png" /><figcaption><a href="https://storage.googleapis.com/gweb-research2023-media/pubtools/6090.pdf">https://storage.googleapis.com/gweb-research2023-media/pubtools/6090.pdf</a></figcaption></figure><h3>LogQ Correction: 필수적인 편향 보정</h3><p>In-Batch Sampled SoftMax에는 중요한 함정이 있습니다. <strong>네거티브 샘플이 긍정적인 상호작용이 발생한 데이터에서 추출되기 때문에, 모델이 인기 있는 아이템에 편향될 수 있습니다.</strong> 자주 노출되고 상호작용한 인기 아이템이 네거티브 샘플로 더 많이 뽑히면서 모델이 이를 ‘진짜 네거티브’로 학습하기 어려워질 수 있습니다.</p><p>이러한 편향을 보정하기 위해 <strong>LogQ Correction</strong>이 필수적입니다. LogQ Correction은 로짓에서 해당 아이템이 데이터 내에서 발생할 로그 확률을 빼는 방식으로 계산됩니다.</p><pre>class SamplingProbabilityCorrection(tf.keras.layers.Layer):<br>    def __call__(self, logits: tf.Tensor, candidate_sampling_probability: tf.Tensor) -&gt; tf.Tensor:<br>        # 로짓에서 후보 아이템의 샘플링 확률의 로그값을 뺌<br>        return logits - tf.math.log(<br>            tf.clip_by_value(candidate_sampling_probability, 1e-6, 1.))</pre><h3>LogQ Correction의 성능 영향</h3><p>오프라인 지표 실험에서 <strong>LogQ Correction을 적용하지 않았을 때 메트릭 기준으로 10%~20% 성능 차이를 보였습니다.</strong> 이는 Two-Tower 모델, 특히 In-Batch Sampled SoftMax를 사용할 때 <strong>LogQ Correction이 모델 성능에 결정적인 영향</strong>을 미친다는 것을 의미합니다.</p><p>따라서 모델 학습 과정에 LogQ Correction을 필수적으로 적용하고 있습니다. 아이템의 샘플링 확률 결정을 위해 다양한 실험을 진행했으며, 아이템 빈도를 활용하여 확률로 사용하는 것이 오프라인 지표에서 가장 좋은 성능을 보였습니다.</p><pre>def get_candidate_probability(df, target_column_name):<br>    id_frequency = df[target_column_name].value_counts()<br>    # Calculate total number of target_product_ids<br>    total_id_counts = len(df[target_column_name])<br>    # Calculate probabilities for each unique product_id<br>    id_probabilities = id_frequency / total_id_counts<br>    id_probabilities = id_probabilities / np.sum(id_probabilities)<br>    return id_probabilities</pre><h3>ANN: 빠른 서빙을 위한 근사검색</h3><p>실제 서비스 환경에서의 효율적인 검색을 위해 ScaNN(Scalable Nearest Neighbors)과 같은 <strong>Approximate Nearest Neighbor (ANN)</strong> 검색 알고리즘을 활용하여 아이템 임베딩을 색인하고 검색 속도를 최적화합니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/363/1*ztWgcm3vMg9d7plDe1eUuw.png" /><figcaption><a href="https://storage.googleapis.com/gweb-research2023-media/pubtools/5716.pdf">https://storage.googleapis.com/gweb-research2023-media/pubtools/5716.pdf</a></figcaption></figure><p>Item Tower는 추천 대상이 정해져 있기 때문에 미리 후보를 추론하여 인덱싱할 수 있고, 이를 활용하면 매우 빠른 시간으로 추론 응답을 할 수 있습니다. TensorFlow 프레임워크를 사용했기에 잘 연동되는 ScaNN을 사용했습니다. 서빙 엔드포인트의 응답 시간 메트릭을 통해 성능을 지속적으로 모니터링하고 있습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/619/1*6-pBbHH2s-7--nu11UCAVA.png" /><figcaption>집계된 서빙 Endpoint 응답 시간 메트릭</figcaption></figure><h3>결론</h3><p>Two-Tower 모델 도입을 통해 얻은 핵심 교훈들</p><h4>1. LogQ Correction의 결정적 중요성</h4><p>In-Batch Sampled SoftMax 사용 시 <strong>LogQ Correction 없이는 10–20% 성능 저하</strong>가 발생했습니다. 아무리 좋은 아키텍처라도 샘플링 편향 보정 없이는 의미가 없다는 것을 확인했습니다.</p><h4>2. MLOps 파이프라인의 실질적 가치</h4><p>Kubeflow Pipelines를 통해 실험 재현성과 관리 효율성이 크게 향상되어 모델 개발에 집중할 수 있었습니다.</p><h4>3. 아키텍처보다 데이터 이해가 우선</h4><p>복잡한 모델 구조보다는 데이터 특성과 학습 과정을 깊이 이해하는 것이 성능 향상의 핵심이었습니다.</p><p>이후 글에서는 사용자 행동 시퀀스 반영 등 더 고도화된 기법에 대해서 소개하도록 하겠습니다. 감사합니다.</p><p>KREAM은 사용자에게 더 나은 탐색 경험을 제공하기 위하여 흥미로우면서도 복잡한 기술적 문제들을 해결해나가고 있습니다. 이러한 여정에 함께할 동료를 항상 찾고 있으니, 관심 있으신 분들의 많은 참여 부탁드립니다!</p><ul><li><a href="https://recruit.kreamcorp.com/">KREAM 채용 페이지</a></li></ul><h3>참고 자료</h3><ul><li><a href="https://dl.acm.org/doi/pdf/10.1145/2959100.2959190">Two-Tower 원논문</a></li><li><a href="https://storage.googleapis.com/gweb-research2023-media/pubtools/5716.pdf">Google Research: Sampling-Bias-Corrected Neural Modeling</a></li><li><a href="https://research.google/blog/announcing-scann-efficient-vector-similarity-search/">ScaNN: Efficient Vector Similarity Search</a></li><li><a href="https://papers.nips.cc/paper/2015/file/86df7dcfd896fcaf2674f757a2463eba-Paper.pdf">Hidden Technical Debt in Machine Learning Systems</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e940817af2bb" width="1" height="1" alt=""><hr><p><a href="https://medium.com/kream-%EA%B8%B0%EC%88%A0-%EB%B8%94%EB%A1%9C%EA%B7%B8/%EB%B0%91%EB%B0%94%EB%8B%A5%EC%97%90%EC%84%9C-%EA%B0%9C%EC%84%A0%ED%95%9C-%EC%B6%94%EC%B2%9C%EC%8B%9C%EC%8A%A4%ED%85%9C-with-two-tower-model-e940817af2bb">밑바닥에서 개선한 추천시스템 with Two-Tower Model</a> was originally published in <a href="https://medium.com/kream-%EA%B8%B0%EC%88%A0-%EB%B8%94%EB%A1%9C%EA%B7%B8">KREAM 기술 블로그</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[밑바닥부터 시작하는 추천시스템 with Kubeflow]]></title>
            <link>https://medium.com/kream-%EA%B8%B0%EC%88%A0-%EB%B8%94%EB%A1%9C%EA%B7%B8/%EB%B0%91%EB%B0%94%EB%8B%A5%EB%B6%80%ED%84%B0-%EC%8B%9C%EC%9E%91%ED%95%98%EB%8A%94-%EC%B6%94%EC%B2%9C%EC%8B%9C%EC%8A%A4%ED%85%9C-with-kubeflow-eed8283e1fbc?source=rss-e74406582b08------2</link>
            <guid isPermaLink="false">https://medium.com/p/eed8283e1fbc</guid>
            <category><![CDATA[recommendations]]></category>
            <category><![CDATA[recsys]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[commerce]]></category>
            <dc:creator><![CDATA[chrisjune]]></dc:creator>
            <pubDate>Wed, 28 May 2025 03:02:26 GMT</pubDate>
            <atom:updated>2025-05-28T05:27:09.084Z</atom:updated>
            <content:encoded><![CDATA[<p>커머스 산업에서 개인화 추천 시스템은 사용자 경험 개선과 매출 증대에 핵심 역할을 합니다. 이를 효율적으로 구현하려면 데이터 처리부터 모델 운영까지 전 과정을 통합 관리할 수 있어야 합니다. 본 글에서는 오픈소스 MLOps 플랫폼인 Kubeflow를 활용한 추천 시스템 구축 사례를 소개합니다.</p><h3>서비스 소개</h3><p>제가 일하는 곳은 리셀 플랫폼으로, 스니커즈 중심에서 테크와 라이프 카테고리까지 확장 중입니다. 국내 최초로 리셀 서비스를 선보였으며, 현재 업계 내 가장 높은 점유율을 보유하고 있습니다. 사용자 경험 강화를 위해 연관 상품, 개인화 추천 등 다양한 추천 모델을 적용해 상품을 노출하고 있습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2PlF8WskuIPB3q1QjOknlA.png" /></figure><h3>프로젝트의 개요 및 목표</h3><p>이 프로젝트의 목표는 기존에 없던 추천 구좌를 도입해 사용자에게 더 나은 탐색 경험을 제공하는 것이었습니다. 이전에는 단순한 구매 수량 기반의 제한적인 추천만 가능했기 때문에, 사용자의 장·단기 선호를 반영한 개인화된 추천이 필요하다고 판단했습니다.</p><p>초기에는 SaaS 기반의 추천 서비스를 연동하는 방안도 검토했으나, 비즈니스 로직을 유연하게 반영하기 어렵다는 한계가 있었습니다. 이에 자체 모델을 구축하는 방향으로 전환하였고, 처음부터 완성도를 높이기보다는 기준이 되는 베이스라인을 설정하고 이를 만족하면 서비스에 반영한 후, 점진적으로 고도화해 나가는 전략을 선택했습니다.</p><h3>기술 스택 및 아키텍처</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*fRWSncWXfOH0MGbA9LKtyA.png" /><figcaption>전체 아키텍쳐</figcaption></figure><p>추천 서비스를 구축하면서 모델 성능만큼이나 이를 둘러싼 인프라가 중요하다는 점을 실감하게 되었습니다. 이 섹션에서는 프로젝트에 사용한 주요 기술 스택과 그 선택 배경에 대해 간략히 소개합니다.</p><h4>데이터 수집 및 전처리 (Kafka/Airflow/HBase)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Vy602KqETVKMNF2F3W9CDg.png" /></figure><p>추천 서비스를 위해 가장 먼저 해야 할 일은 사용자 이벤트 데이터를 안정적으로 수집하고, 이를 모델 학습에 적합한 형태로 가공하는 것이었습니다.</p><p>사용자 이벤트가 발생하면 클라이언트에서 이벤트 프록시 서버를 호출하고, 해당 서버는 Kafka로 이벤트를 프로듀싱합니다. Kafka에 들어온 데이터는 이벤트 워커 서버를 통해 멀티 컨슈밍되며, Amplitude, HBase, Braze 등 다양한 저장소로 분기되어 저장됩니다. Kafka 기반 이벤트 파이프라인은 사내 동료(Key🔑)가 이미 구축해두어 쉽게 활용할 수 있었습니다.</p><p>HBase에 저장된 데이터는 Airflow를 통해 10분 간격으로 스케줄링되어 Hadoop에 전처리되어 저장됩니다. 이 전처리 단계에서는 불필요한 필드를 제거하고, 시간 정보를 표준 포맷으로 변환하는 등의 작업이 수행됩니다. Hadoop은 대용량 데이터를 저장하기 위한 선택이었고, Hadoop 자체에 대한 깊은 이해보다는 실용적인 관점에서 활용했습니다.</p><p>초기에는 데이터를 MySQL 등 RDB에 저장하고 쿼리를 통해 전처리하는 방식을 고려했지만, 속도와 확장성에 한계가 있었습니다. 이후에는 Kubernetes 기반으로 배포 가능한 MySQL 호환 시스템인 Vitess를 도입해보았지만, 데이터 처리량 제한과 복잡한 조인 쿼리에 제약이 있어 대용량 처리에는 적합하지 않았습니다.</p><p>Airflow는 직접 운영하지 않고, 사내에서 제공하는<a href="https://deview.kr/2021/sessions/515">Cquery</a>라는 내부 서비스를 활용했습니다. Cquery는 SQL 기반으로 간단한 전처리 작업을 쉽게 구성할 수 있고, 손쉽게 스케줄링할 수 있다는 장점이 있어 매우 유용했습니다. (자세한 내용은 관련 문서를 참고해 주세요.)</p><h4>모델 학습 및 서빙 (Matrix Factorization, FastAPI)</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wN7aUVsk98OMpgpkEAPCpA.png" /></figure><p>추천 모델로는 협업 필터링(Collaborative Filtering)의 대표적인 기법인 <strong>Matrix Factorization(MF)</strong> 을 선택했습니다. 이 알고리즘은 사용자와 아이템 간의 상호작용 데이터를 기반으로 잠재 요인을 학습해 추천을 수행하는 방식으로, 비교적 높은 정확도와 병렬 학습이 가능한 장점을 가지고 있습니다.</p><p>MF 알고리즘은 널리 사용되는 만큼 다양한 오픈소스 라이브러리가 잘 갖춰져 있어 구현과 실험이 용이했습니다. 따라서 본 프로젝트에서는 <strong>베이스라인 모델</strong>로 MF를 적용하고, 이후 점진적으로 고도화해 나가는 전략을 취했습니다.</p><p>모델 학습 및 파이프라인 구성에는 <strong>Kubeflow</strong>를 활용했습니다. Kubeflow는 Kubernetes 환경에서 머신러닝 워크로드를 효율적으로 실행하고 관리할 수 있도록 돕는 프레임워크로, 모델 학습부터 서빙까지의 과정을 자동화된 파이프라인으로 구성할 수 있다는 장점이 있습니다.</p><p>서빙은 <strong>FastAPI</strong>를 이용해 모델 추론 API를 구성하고, 이를 Kubernetes 환경에 배포해 운영 중입니다. FastAPI는 경량화된 구조와 높은 성능 덕분에 빠른 응답 속도가 요구되는 추천 시스템 서빙에 적합했습니다.</p><h3>Kubeflow를 활용한 MLOps 구현 맛보기</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ksb22z_ymk0p1Lgp49kgwA.png" /><figcaption>모델 학습 및 서빙 Full pipeline</figcaption></figure><p>Kubeflow가 제공하는 기본 컴포넌트를 활용하여 모델 학습부터 서빙까지의 전체 MLOps 흐름을 구성할 수 있습니다. 이 섹션에서는 간단한 예제를 통해 파이프라인 구성 과정을 소개합니다.</p><p><strong>Kubeflow Pipelines(KFP)</strong> 라이브러리를 사용하면 파이썬 코드로 손쉽게 파이프라인을 정의할 수 있습니다. 예시 파이프라인에서는 다음과 같은 단계를 포함합니다</p><ol><li><strong>데이터 불러오기 (Data Volume Mount)</strong></li><li><strong>모델 학습 (Training)</strong></li><li><strong>모델 서빙 (Deployment)</strong></li></ol><p>이러한 과정을 하나의 파이프라인으로 묶어 실행하면, 데이터 처리부터 모델 배포까지 전 과정을 자동화할 수 있습니다. Kubeflow UI 상에서도 각 단계의 흐름과 상태를 시각적으로 확인할 수 있어 운영 및 관리가 용이합니다.</p><h4>1. 학습용 코드 도커라이징</h4><p>Kubeflow에서 모델을 학습하려면, 먼저 학습 코드를 <strong>Docker 이미지</strong>로 패키징해야 합니다. 아래는 대표적인 예시로, CUDA 기반 베이스 이미지에 Python 및 필요한 서드파티 라이브러리를 설치하고, 학습 코드를 복사하는 방식입니다:</p><pre>FROM nvidia/cuda:11.8.0-runtime-ubuntu18.04<br> <br># Install python<br>RUN apt-get install -y python3.9 python3-pip<br> <br># Copy source code<br>WORKDIR /app<br> <br>COPY requirements.txt .<br>RUN pip3 install --upgrade pip<br>RUN pip3 install --no-cache-dir -r requirements.txt<br> <br>COPY ./src /app/src<br>ENV PYTHONPATH /app/src</pre><p>이렇게 도커라이징한 이미지는 컨테이너 환경에서 Kubeflow가 학습 작업을 실행할 수 있도록 해줍니다. 추후 파이프라인 정의 시 이 이미지를 사용해 학습 스텝을 구성하게 됩니다.</p><h4>2. 컴포넌트 정의 및 YAML 기반 배포 설정</h4><p>앞서 도커라이징한 학습 이미지를 Kubeflow 파이프라인에서 실행하려면, 해당 컨테이너의 실행 커맨드를 <strong>YAML 형식의 메니페스트</strong>로 정의해야 합니다. 이 YAML은 Kubeflow Pipeline에서 kfp.components.load_component_from_text() 함수를 사용해 <strong>컴포넌트화</strong>할 수 있습니다.</p><p>또한, 모델 학습이나 데이터 저장 등을 위해 필요한 <strong>Persistent Volume Claim(PVC)</strong> 도 이 단계에서 함께 마운트할 수 있습니다.</p><p>아래는 실제 파이프라인 코드의 예시로, kfp.dsl.VolumeOp 명령어로 볼륨을 생성한 뒤, 컴포넌트에 마운트하여 실행하는 방식입니다:</p><pre>import kfp<br>from kfp import dsl<br>from kubernetes import client as k8s_client<br><br>@dsl.pipeline(<br>    name=&quot;Recommendation Model Pipeline&quot;,<br>    description=&quot;Train and export a recommendation model&quot;<br>)<br>def recsys_pipeline():<br>    # 컴포넌트 정의 (YAML 텍스트 기반)<br>    recommend_train_yaml = &quot;&quot;&quot;<br>    name: Recommend Trainer<br>    description: Train recommendation model<br><br>    inputs:<br>    - {name: Dataset Path, type: String, default: &#39;&#39;, description: &#39;Path to raw dataset&#39;}<br>    - {name: Model Inference Path, type: String, default: &#39;&#39;, description: &#39;Model inference output path&#39;}<br>    outputs:<br>    - {name: Model Output Path, type: String, description: &#39;Path to save trained model&#39;}<br><br>    implementation:<br>      container:<br>        image: dockerhub.com/chrisjune/model-trainer:latest<br>        command: [<br>          python3, /app/src/model_trainer.py,<br>          --dataset_path, {inputValue: Dataset Path},<br>          --model_inference_path, {inputValue: Model Inference Path},<br>          --model_output_path, {outputPath: Model Output Path},<br>        ]<br>    &quot;&quot;&quot;<br><br>    # 볼륨 생성 (HDFS 기반 PVC)<br>    data_volume = dsl.VolumeOp(<br>        name=&quot;dataset-volume&quot;,<br>        resource_name=&quot;recsys-data&quot;,<br>        size=&quot;5Gi&quot;,<br>        storage_class=&quot;alluxio&quot;,<br>        modes=[&quot;ReadOnlyMany&quot;],<br>        annotations={&quot;hdfs/path&quot;: &quot;/{hdfs_dataset_path}&quot;}<br>    )<br><br>    # 컴포넌트 로딩 및 실행<br>    train_op = kfp.components.load_component_from_text(recommend_train_yaml)<br><br>    train_task = (<br>        train_op(<br>            dataset_path=&quot;/mnt/dataset&quot;,<br>            model_inference_path=&quot;/mnt/inference&quot;<br>        )<br>        .add_volume(<br>            k8s_client.V1Volume(<br>                name=&quot;dataset-volume&quot;,<br>                persistent_volume_claim=k8s_client.V1PersistentVolumeClaimVolumeSource(<br>                    claim_name=data_volume.outputs[&quot;name&quot;]<br>                ),<br>            )<br>        )<br>        .add_volume_mount(<br>            k8s_client.V1VolumeMount(<br>                mount_path=&quot;/mnt/dataset&quot;,<br>                name=&quot;dataset-volume&quot;<br>            )<br>        )<br>        .set_cpu_limit(&quot;8&quot;).set_memory_limit(&quot;64Gi&quot;).set_gpu_limit(1)<br>        .add_pod_annotation(&quot;sidecar.istio.io/inject&quot;, &quot;false&quot;)<br>    )</pre><p>이렇게 구성된 파이프라인은 데이터 준비, 학습, 서빙 등의 스텝을 하나의 흐름으로 연결하며, PVC를 통해 각 단계 간 데이터를 공유할 수 있습니다.</p><h4>3. 추천 웹서버 개발 및 컨테이너 도커라이징</h4><p>학습된 모델을 서비스에 활용하기 위해, FastAPI 기반의 경량 웹 서버를 구현하고 이를 컨테이너화했습니다. 서버는 모델을 로드하고, 사용자 ID를 기반으로 추천 결과를 반환하는 단순한 API 구조를 따릅니다.</p><pre>from fastapi import FastAPI<br>from pydantic import BaseModel<br> <br>### 모델 로드 #################################<br>model = None<br>async def init_model():<br>    global model<br>    with open(MODEL_PATH, &quot;rb&quot;) as f:<br>            model = pickle.load(f)<br> <br>app = FastAPI()<br>@app.on_event(&quot;startup&quot;)<br>async def load_model_and_data():<br>    await init_model()<br>#############################################<br> <br> <br>### API Endpoint ############################<br>class RecommendByUserId(BaseModel):<br>    user_id: int<br>    top_k: Optional[int] = TOP_K<br> <br>async def get_recommendations_for_user(user_id, top_k):<br>        pass<br> <br>@app.get(&quot;/recommend/{user_id}&quot;)<br>async def get_recommendations(request: RecommendByUserId):<br>    recommendations = await get_recommendations_for_user(request.user_id, request.top_k)<br>    return {&quot;recommendations&quot;: recommendations}<br>#############################################</pre><p>이 서버는 모델을 애플리케이션 시작 시 한 번 로드하고, 이후 REST API를 통해 사용자별 추천을 제공합니다.</p><h4>4. 모델 서빙: KServe 연동</h4><p>FastAPI로 만든 서버를 직접 Kubernetes에 배포할 수도 있지만, 더 구조화된 서빙을 위해 Kubeflow의 <strong>KServe 컴포넌트</strong>를 활용했습니다. KServe는 표준화된 방식으로 모델을 Kubernetes 상에 배포하고 관리할 수 있도록 도와줍니다.</p><pre>from kfp import components<br><br># KServe 컴포넌트 로드<br>kserve_op = components.load_component_from_url(https://medium.com/%3Cbr%3E%20%20%20%20&quot;https://raw.githubusercontent.com/kubeflow/pipelines/master/components/kserve/component.yaml&quot;%3Cbr%3E)<br><br># InferenceService 정의 (YAML 형태)<br>infer_serv_yaml = &quot;&quot;&quot;<br>apiVersion: serving.kserve.io/v1beta1<br>kind: InferenceService<br>metadata:<br>  name: example-sklearn-isvc<br>spec:<br>  predictor:<br>    model:<br>      modelFormat:<br>        name: sklearn<br>      storageUri: hdfs://bucket/sklearn/mnist.joblib<br>      runtime: kserve-mlserver<br>&quot;&quot;&quot;<br><br># 모델 서빙 실행<br>kserve_op(<br>    action=&quot;apply&quot;,<br>    inferenceservice_yaml=infer_serv_yaml,<br>    watch_timeout=&quot;800&quot;,<br>)</pre><p>이 구성에서는 InferenceService YAML을 통해 S3나 HDFS등 스토리지에 저장된 모델 아티팩트를 불러오고, kserve-mlserver 런타임으로 서빙합니다. 필요한 경우 FastAPI 기반의 커스텀 서버를 포함해 컨테이너 이미지를 직접 지정해 사용하는 것도 가능합니다.</p><h3>성능 평가 및 추론 속도 개선</h3><h4>하이퍼파라미터 튜닝</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YkNTUqw39MWDJsGox2YQ8g.png" /></figure><p>커머스 서비스 특성상, 단순 정확도보다 <strong>추천 결과의 노출 순서</strong>가 더 중요합니다. 이에 따라 모델의 성능 평가 지표로는 <strong>NDCG (Normalized Discounted Cumulative Gain)</strong> 와 <strong>MAP (Mean Average Precision)</strong> 을 사용했습니다. 이 두 지표는 추천 리스트 내에서 상위에 얼마나 관련도 높은 아이템이 위치했는지를 측정해줍니다.</p><p>초기에는 하이퍼파라미터 튜닝을 위해 반복(iteration)별 성능을 시각화해 최적점을 찾으려 했습니다. 그러나 평가 지표가 두 개 이상이다 보니, 단순 플로팅 기반 접근으로는 최적의 조합을 식별하는 데 한계가 있었습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qCjSpzM0uAbtd3Ut9XKGgA.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7R7-2VrZkFlvFLaXLt2RMw.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Obx8p9tAJEvRhQZEAeR8jQ.png" /><figcaption>초기 방식의 파라미터 튜닝</figcaption></figure><p>이후, <strong>Kubeflow의 AutoML 컴포넌트인 Katib</strong>을 활용하여 튜닝 작업을 자동화했습니다. Katib은 다양한 하이퍼파라미터 조합을 실험하고, 정해진 목표(metric)를 기준으로 최적값을 찾아주는 도구입니다.</p><p>Katib을 사용하기 위해 다음과 같은 작업을 수행했습니다:</p><ul><li>학습 코드에서 하이퍼파라미터를 <strong>외부 환경 변수(예: argparse, os.environ)</strong> 로 받아들일 수 있도록 수정</li><li>파라미터를 바인딩할 수 있도록 학습 컨테이너와 파이프라인 구성</li><li>실험 결과를 기준으로 <strong>최적의 조합을 자동 선택</strong>하고 파이프라인에 반영</li></ul><p>이를 통해 반복적인 수작업 튜닝을 줄이고, 효율적으로 모델 성능을 개선할 수 있었습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s_HuRdy8fApwiAUTU8EqcQ.png" /><figcaption>Katib을 활용한 파라미터 튜닝</figcaption></figure><h4>성능개선</h4><p>서비스의 실시간성과 사용자 경험을 고려해, 모델 추론 방식에 변화를 주어 응답 속도를 <strong>10배 이상 개선</strong>할 수 있었습니다.</p><p>기존에는 API 요청 시마다 실시간으로 모델 추론을 수행하는 방식이었으며, 평균 응답 속도는 <strong>50ms 이하</strong>로 나쁘지 않은 수준이었습니다. 그러나 이후 백엔드 서비스에서 상품 정보를 추가로 조회해야 했기 때문에, <strong>전체 응답 속도를 더 줄일 필요</strong>가 있었습니다.</p><p>이에 따라, 실시간 추론 방식을 <strong>오프라인 추론 기반</strong>으로 전환했습니다. 구체적으로는 미리 사용자별 추천 결과를 추론하여 저장해두고, API 요청 시에는 해당 결과만 빠르게 조회하는 방식입니다. 이를 통해 실시간 모델 인퍼런스 과정을 제거하고, 응답 시간을 획기적으로 단축할 수 있었습니다.</p><p>그 결과, API의 응답 속도를 약 <strong>10배 수준으로 증가</strong>시켰으며, 전체 시스템 부하도 크게 줄어드는 효과를 얻을 수 있었습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*IPm7hqHINpr1g2CrfK08Hg.png" /></figure><h3>추천 시스템, 꼭 ML로 시작해야 할까?</h3><p>머신러닝 서비스를 준비할 때 가장 먼저 고민해볼 질문은 바로 이것입니다:</p><blockquote><strong><em>“이 문제가 정말 머신러닝으로 풀어야 하는 문제일까?”</em></strong></blockquote><p>예를 들어, 상품 추천 서비스를 만들기 위해 반드시 딥러닝 프레임워크나 복잡한 모델이 필요한 것은 아닙니다. <strong>추천 대상 상품(SKU)의 수가 적거나, 사용자 행동 데이터가 아직 충분하지 않은 초기 단계</strong>라면, SQL 쿼리만으로도 훌륭한 추천 시스템을 구현할 수 있습니다.</p><h4>SQL 기반 연관 상품 추천 예시</h4><p>다음은 user_id, item_id, 그리고 이벤트 수(count) 컬럼을 가진 테이블을 기반으로, <strong>Item-based Cosine 유사도</strong>를 활용한 추천 쿼리 예시입니다.</p><pre>user_id, item_id, 이벤트 수 count 컬럼이 있는 event 테이블이 있다고 가정<br> <br>-- 이벤트 데이터를 normalize<br>create table normalized_event<br>select user_id, item_id, w / sqrt(sum(w * w) over partition by user_id) w<br>from (select user_id, item_id, ln(count) + 1 w from event) t;<br> <br>-- Item based cosine 유사도를 계산한 결과를 테이블에 저장<br>create table event_cosine_sim as<br>select a_item, b_item, sim<br>from (select a_item, b_item, sim, row_number() over (partition by a_item order by sim desc) rownum<br>      from (select a.item_id a_item, b.item_id b_item, sum(a.w * b.w) sim<br>            from normalized_event a<br>                     inner join normalized_event b on a.user_id = b.user_id and a.item_id != b.item_id<br>            group by a.item_id, b.item_id) t) t2<br>where rownum &lt; 10;<br> <br>-- 연관상품 추천<br>select b_item &quot;추천된 상품&quot;<br>from event_cosine_sim<br>where a_item = &quot;{상품번호}&quot;<br>order by sim desc;</pre><h3>결론 및 향후 계획</h3><p>머신러닝 서비스를 백엔드 서비스처럼 깔끔한 아키텍처로 설계하는 일은 생각보다 훨씬 복잡합니다. 구글의 유명한 논문 <a href="https://proceedings.neurips.cc/paper_files/paper/2015/file/86df7dcfd896fcaf2674f757a2463eba-Paper.pdf"><em>Hidden Technical Debt in Machine Learning Systems</em></a>에서도 언급했듯, 머신러닝 시스템의 복잡성은 대부분 <strong>모델 외부의 시스템 레이어</strong>에 존재합니다. 실제 모델 코드는 전체 시스템에서 극히 일부에 불과합니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/450/1*5H9P9EnAEsfxvboPrskoMQ.png" /><figcaption><a href="https://proceedings.neurips.cc/paper_files/paper/2015/file/86df7dcfd896fcaf2674f757a2463eba-Paper.pdf">https://proceedings.neurips.cc/paper_files/paper/2015/file/86df7dcfd896fcaf2674f757a2463eba-Paper.pdf</a></figcaption></figure><p>ML 시스템은 다양한 외부 파이프라인에 대한 의존성이 크고, 각 처리 단계가 밀접하게 연결(tightly coupled)되어 있어 단순한 코드 분리나 추상화가 쉽지 않습니다. 또한 전통적인 백엔드 개발에서 사용하는 <strong>단위 테스트</strong>, <strong>의존성 주입</strong>, <strong>모듈화 패턴</strong> 등을 적용하기도 어렵습니다. 전체 파이프라인을 작은 데이터셋으로 끝까지 테스트해야 하기 때문에 <strong>테스트 비용</strong>도 상대적으로 큽니다.</p><p>이런 복잡한 환경 속에서도 <strong>Kubeflow와 Kubeflow Pipelines(KFP)</strong> 는 많은 도움을 주었습니다. 파이프라인을 구성하는 데 필요한 반복 작업을 자동화하고, 실험의 <strong>재현성과 관리 효율성</strong>을 크게 향상시켜 주었습니다. 덕분에 모델 개발과 실험에 보다 집중할 수 있는 환경을 만들 수 있었습니다.</p><p>앞으로는 이번 시스템에 적용된 추천 모델을 어떻게 개선해 나갔는지에 대한 구체적인 사례와 실험 결과를 다음 글에서 더 자세히 공유드릴 예정입니다.</p><h3>KREAM CAREER</h3><blockquote><strong><em>함께할 동료를 찾습니다.</em></strong></blockquote><blockquote><em>KREAM은 ‘한정판의 가치를 연결한다’라는 미션으로 출발했습니다. 한정판 아이템부터 B2B 솔루션, 새로운 카테고리까지 비즈니스 영역을 지속적으로 확장하며, 검수 시스템, 실시간 거래, 추천 알고리즘, 검색 최적화 등 흥미로우면서도 복잡한 기술적 문제들을 해결하고 있습니다.</em></blockquote><blockquote><em>특히 현재 우리와 함께 추천·검색 영역의 혁신을 이끌어갈 기획자를 찾고 있습니다. 만약 우리와 함께 한정판 문화를 넘어 새로운 커머스 패러다임을 만들어가고 싶다면, 주저하지 말고 KREAM에 합류하세요!</em></blockquote><blockquote><em>👉 </em><a href="https://recruit.kreamcorp.com/rcrt/view.do?annoId=30003417&amp;sw=&amp;subJobCdArr=&amp;sysCompanyCdArr=&amp;empTypeCdArr=&amp;entTypeCdArr=&amp;workAreaCdArr="><em>추천·검색 기획자 채용 공고 보기</em></a></blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=eed8283e1fbc" width="1" height="1" alt=""><hr><p><a href="https://medium.com/kream-%EA%B8%B0%EC%88%A0-%EB%B8%94%EB%A1%9C%EA%B7%B8/%EB%B0%91%EB%B0%94%EB%8B%A5%EB%B6%80%ED%84%B0-%EC%8B%9C%EC%9E%91%ED%95%98%EB%8A%94-%EC%B6%94%EC%B2%9C%EC%8B%9C%EC%8A%A4%ED%85%9C-with-kubeflow-eed8283e1fbc">밑바닥부터 시작하는 추천시스템 with Kubeflow</a> was originally published in <a href="https://medium.com/kream-%EA%B8%B0%EC%88%A0-%EB%B8%94%EB%A1%9C%EA%B7%B8">KREAM 기술 블로그</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[[ML] Negative sampling]]></title>
            <link>https://chrisjune-13837.medium.com/ml-negative-sampling-b0182491312f?source=rss-e74406582b08------2</link>
            <guid isPermaLink="false">https://medium.com/p/b0182491312f</guid>
            <dc:creator><![CDATA[chrisjune]]></dc:creator>
            <pubDate>Wed, 04 Dec 2024 09:18:54 GMT</pubDate>
            <atom:updated>2025-04-16T07:27:50.975Z</atom:updated>
            <content:encoded><![CDATA[<p>대부분의 데이터는 User feedback의 implicit data인 경우가 많습니다. 이럴 경우 negative sampling을 하여 학습을 위한 전처리 작업을 합니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uF5KHFwOidpZdTG8azfjsA.png" /></figure><p>아래에는 가장 일반적인 Negative sampling을 하는 코드예시입니다.</p><ol><li>샘플링을 위해 예시 데이터로 유저4만명, 상품2만개, Interaction 20만개를 가정합니다.</li></ol><pre>import pandas as pd<br>import numpy as np<br>import random<br><br>random.seed(42)<br>np.random.seed(42)<br><br>num_users = 40000     # Number of users<br>num_items = 20000     # Number of items<br>num_interactions = 200000  # Number of positive interactions<br><br>user_ids = np.arange(1, num_users + 1)<br>item_ids = np.arange(1, num_items + 1)<br><br>positive_user_ids = np.random.choice(user_ids, size=num_interactions, replace=True)<br>positive_item_ids = np.random.choice(item_ids, size=num_interactions, replace=True)<br><br>timestamps = pd.date_range(start=&#39;2024-01-01&#39;, periods=100000, freq=&#39;T&#39;)<br>random_timestamps = np.random.choice(timestamps, size=num_interactions, replace=True)<br><br># Create the interactions DataFrame<br>interactions = pd.DataFrame({<br>    &#39;UserId&#39;: positive_user_ids,<br>    &#39;ItemId&#39;: positive_item_ids,<br>    &#39;Time&#39;: random_timestamps<br>})</pre><p>2. Negative sample을 고를때 제외하기 위하여 Interaction을 set으로 만들어줍니다.</p><pre>user_item_dict = interactions.groupby(&#39;UserId&#39;)[&#39;ItemId&#39;].apply(set).to_dict()</pre><p>3. 전체 User를 순회하며 전체상품에서 Interaction을 제외한 상품을 샘플링하는 메서드를 만들어줍니다.</p><pre>from tqdm import tqdm <br>def negative_sampling(user_ids, item_ids, user_item_dict, num_negatives=4):<br>    negative_samples = []<br>    all_items = set(item_ids)<br>    <br>    for user_id in tqdm(user_ids):<br>        interacted_items = user_item_dict.get(user_id, set())<br>        non_interacted_items = all_items - interacted_items<br>        <br>        if len(non_interacted_items) &gt;= num_negatives:<br>            negatives = random.sample(non_interacted_items, num_negatives)<br>        else:<br>            negatives = list(non_interacted_items)<br>        <br>        for item_id in negatives:<br>            negative_samples.append({&#39;UserId&#39;: user_id, &#39;ItemId&#39;: item_id, &#39;Label&#39;: 0})<br>    return negative_samples<br><br>unique_user_ids = interactions[&#39;UserId&#39;].unique()<br>unique_item_ids = interactions[&#39;ItemId&#39;].unique()<br><br>negatives = negative_sampling(unique_user_ids, unique_item_ids, user_item_dict, num_negatives=4)<br><br>negatives_df = pd.DataFrame(negatives)</pre><p>수행시간은 M1맥북프로기준 15초정도 소요되었습니다.</p><p>Triplet으로 Negative sampling을 하려면 아래와 같이 메서드를 만드시면 됩니다.</p><pre>from tqdm import tqdm <br>def negative_sampling(user_ids, item_ids, user_item_dict):<br>    negative_samples = []<br>    all_items = set(item_ids)<br>    triplets = []<br>    for user_id in tqdm(user_ids):<br>        postive_items = user_item_dict.get(user_id, set())<br>        negative_items = all_items - postive_items<br>        <br>        # If there are enough non-interacted items, sample num_negatives items<br>        if negative_items:<br>            for positive_item in postive_items:<br>                neg_item = np.random.choice(list(negative_items))<br>                triplets.append({&quot;userId&quot;: user_id, &quot;posItemId&quot;: positive_item, &quot;negItemId&quot;: neg_item})<br>    return triplets<br><br># Get unique user IDs and item IDs from the interactions<br>unique_user_ids = interactions[&#39;UserId&#39;].unique()<br>unique_item_ids = interactions[&#39;ItemId&#39;].unique()<br><br># Generate negative samples<br>negatives = negative_sampling(unique_user_ids, unique_item_ids, user_item_dict, num_negatives=4)<br><br># Convert negative samples to DataFrame<br>negatives_df = pd.DataFrame(negatives)</pre><p>수행시간은 M1맥북프로기준 6분정도 소요되었습니다.</p><p>위의 예시처럼 전체 상품에서 Negative를 뽑을 수도 있지만, 데이터가 훨씬 더 많고 sparse하고, 학습속도를 효율적으로 하기 위하여 In-batch negative sampling과 logQ loss correction을 통하여 성능을 높일 수 있습니다. 이와 관련된 내용은 <a href="https://chrisjune-13837.medium.com/paper-review-sampling-bias-corrected-neural-modeling-for-large-corpus-item-recommendations-fee7710c5640">해당 포스트</a>를 참고하시면 좋을 것 같습니다.</p><p>감사합니다.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b0182491312f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[[ML] ScaNN을 활용한 TensorFlow 모델 서빙과 인퍼런스 속도 개선]]></title>
            <link>https://chrisjune-13837.medium.com/ml-scann%EC%9D%84-%EC%9D%B4%EC%9A%A9%ED%95%98%EC%97%AC-tensorflow-%EB%AA%A8%EB%AA%A8%EB%8D%B8-inference-%EC%86%8D%EB%8F%84-%EB%86%92%EC%9D%B4%EA%B8%B0-4253adced9d1?source=rss-e74406582b08------2</link>
            <guid isPermaLink="false">https://medium.com/p/4253adced9d1</guid>
            <category><![CDATA[annoy]]></category>
            <category><![CDATA[scann]]></category>
            <category><![CDATA[faiss]]></category>
            <category><![CDATA[pytorch]]></category>
            <category><![CDATA[tensorflow]]></category>
            <dc:creator><![CDATA[chrisjune]]></dc:creator>
            <pubDate>Fri, 08 Nov 2024 05:06:48 GMT</pubDate>
            <atom:updated>2024-11-11T08:08:34.680Z</atom:updated>
            <content:encoded><![CDATA[<p>ANN(Approximate Nearest Neighbor) Vector search model인 ScaNN을 사용하여 Tensorflow 모델 서빙과 인퍼런스를 빠르게 할 수 있는 방법을 공유합니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*MaH9Ex_5cSaX-3Nu.png" /></figure><p>ANN(Approximate Nearest Neighbor) 모델에는 여러 종류가 있으며, 그중에서도 <strong>Annoy</strong>와 <strong>Faiss</strong>가 많이 알려져 있습니다. 저는 <strong>TensorFlow Recommenders</strong>(TFRS)를 사용해왔고, TFRS 내에서 동작하는 ANN 모델로 <strong>ScaNN</strong>을 활용했습니다. 그러나 TFRS 의존성을 줄이고자 ScaNN을 별도로 구현하여, 학습된 TensorFlow 모델에서 ScaNN을 사용하는 방법을 공유하려 합니다.</p><p>Faiss로 학습 결과를 추출한 뒤 <strong>Flask</strong>나 <strong>FastAPI</strong>로 서빙할 수도 있지만, <strong>TF-serving</strong>의 추론 속도가 10배 이상 빠르기 때문에 이를 활용하여 별도의 서빙용 모델을 제작했습니다.</p><p>핵심은 학습 모델과 서빙 모델을 분리하고, 서빙 모델에 ScaNN layer를 추가하는 것입니다.</p><h3>Dual Encoder 모델 정의 예시</h3><h4>학습할 모델 정의</h4><p>먼저, Dual Encoder (Two-Tower) 모델을 정의하고 학습합니다.</p><pre>import tensorflow as tf<br>from tensorflow.keras.layers import Input, Embedding, Dot, Dense, Flatten<br>from tensorflow.keras.models import Model<br><br>def create_model(ids):<br>    # Define the embedding dimensions<br>    embedding_dim = 32<br>    user_vocab_size = 1000  # Adjust according to your dataset<br>    product_vocab_size = 1000  # Adjust according to your dataset<br>    <br>    # User tower<br>    user_input = Input(shape=(1,), name=&#39;user_id&#39;)<br>    user_embedding = Embedding(input_dim=user_vocab_size, output_dim=embedding_dim, name=&#39;user_embedding&#39;)(user_input)<br>    user_embedding = Flatten()(user_embedding)<br>    user_embedding = Dnese(embedding_dim, name=&#39;user_embedding&#39;)(user_embedding)<br>    <br>    # Candidate (product) tower<br>    product_input = Input(shape=(1,), name=&#39;product_id&#39;)<br>    product_embedding = Embedding(input_dim=product_vocab_size, output_dim=embedding_dim, name=&#39;product_embedding&#39;)(product_input)<br>    product_embedding = Flatten()(product_embedding)<br>    product_embedding = Dnese(embedding_dim, name=&#39;product_embedding&#39;)(product_embedding)<br>    <br>    # Create the model<br>    model = Model(inputs=[user_input, product_input], outputs=[user_embedding, product_embedding])<br>    return model</pre><h4>ScaNN 라이브러리 설치 및 ScaNN 클래스 정의</h4><p>ScaNN 라이브러리를 설치하고, 이를 기반으로 Searcher를 사용하는 클래스를 정의합니다. <a href="https://github.com/tensorflow/recommenders/blob/v0.7.3/tensorflow_recommenders/layers/factorized_top_k.py#L596-L766">해당 코드는 TFRS ScaNN 클래스를 참고하였습니다.</a></p><pre>&gt; pip install scann</pre><pre>import scann<br>import tensorflow as tf<br><br><br>class ScaNN(tf.keras.layers.Layer):<br>    def __init__(self,<br>                 num_neighbors=10,<br>                 distance_measure=&#39;dot_product&#39;,<br>                 num_leaves=500,<br>                 num_leaves_to_search=50,<br>                 training_iterations=10,<br>                 dimensions_per_block=2,<br>                 num_reordering_candidates=550,<br>                 parallelize_batch_searches=True,<br>                 name=None):<br>        super().__init__(name=name)<br>        self.num_neighbors = num_neighbors<br>        self.distance_measure = distance_measure<br>        self.num_leaves = num_leaves<br>        self.num_leaves_to_search = num_leaves_to_search<br>        self.training_iterations = training_iterations<br>        self.dimensions_per_block = dimensions_per_block<br>        self.num_reordering_candidates = num_reordering_candidates<br>        self.parallelize_batch_searches = parallelize_batch_searches<br>        self._serialized_searcher = None<br>        self._identifiers = None<br><br>    def index(self, candidates, identifiers=None):<br>        if identifiers is None:<br>            identifiers = tf.range(tf.shape(candidates)[0])<br><br>        # Build the ScaNN searcher<br>        builder = scann.scann_ops.builder(<br>            candidates,<br>            num_neighbors=self.num_neighbors,<br>            distance_measure=self.distance_measure<br>        )<br>        builder = builder.tree(<br>            num_leaves=self.num_leaves,<br>            num_leaves_to_search=self.num_leaves_to_search,<br>            training_iterations=self.training_iterations<br>        )<br>        builder = builder.score_ah(dimensions_per_block=self.dimensions_per_block)<br>        if self.num_reordering_candidates is not None:<br>            builder = builder.reorder(self.num_reordering_candidates)<br>        searcher = builder.build()<br><br>        # Serialize the searcher<br>        self._serialized_searcher = searcher.serialize_to_module()<br>        self._identifiers = tf.Variable(identifiers, trainable=False, name=&#39;identifiers&#39;)<br><br>    @tf.function<br>    def call(self, queries, k=None):<br>        if k is None:<br>            k = self.num_neighbors<br>        if self._serialized_searcher is None:<br>            raise ValueError(&quot;The `index` method must be called before querying.&quot;)<br><br>        # Deserialize the searcher<br>        searcher = scann.scann_ops.searcher_from_module(self._serialized_searcher)<br><br>        # Perform the search<br>        if tf.rank(queries) == 2:<br>            if self.parallelize_batch_searches:<br>                result = searcher.search_batched_parallel(queries, final_num_neighbors=k)<br>            else:<br>                result = searcher.search_batched(queries, final_num_neighbors=k)<br>            indices = result.indices<br>            distances = result.distances<br>        else:<br>            result = searcher.search(queries, final_num_neighbors=k)<br>            indices = result.index<br>            distances = result.distance<br><br>        # Map indices back to identifiers<br>        identifiers = tf.gather(self._identifiers, indices)<br>        return distances, identifiers</pre><h4>서빙을 위한 모델 재정의</h4><p>학습된 모델의 임베딩과 ScaNN index를 활용하여 서빙 모델을 정의합니다.</p><pre>from scann_model import ScaNN<br>import tensorflow as tf<br><br>class RetrievalModel(tf.keras.Model):<br>    def __init__(self, query_model, scann_layer):<br>        super().__init__()<br>        self.query_model = query_model<br>        self.scann_layer = scann_layer<br><br>    @tf.function(input_signature=[tf.TensorSpec(shape=[None], dtype=tf.int32)])<br>    def call(self, product_id):<br>        # Compute query embeddings<br>        query_embeddings = self.query_model(product_id)<br><br>        # Retrieve top candidates<br>        distances, identifiers = self.scann_layer(query_embeddings)<br><br>        return distances, identifiers<br><br>unique_item_ids = dataset[&#39;product_id&#39;].unique().tolist()<br><br>candidate_model = tf.keras.Model(<br>    inputs=model.get_layer(&#39;product_id&#39;).input,<br>    outputs=model.get_layer(&#39;product_embedding&#39;).output<br>)<br># Compute candidate embeddings<br>candidate_embeddings = candidate_model(tf.constant(unique_item_ids))<br><br># Step 3: Build the ScaNN index<br>scann_layer = ScaNN(num_neighbors=30)<br>scann_layer.index(candidate_embeddings, identifiers=tf.constant(unique_item_ids))<br><br>query_model = tf.keras.Model(<br>    inputs=model.get_layer(&#39;product_id&#39;).input,<br>    outputs=model.get_layer(&#39;product_embedding&#39;).output<br>)<br>retrieval_model = RetrievalModel(query_model=query_model, scann_layer=scann_layer)<br>return retrieval_model</pre><h4>모델 저장 및 로드</h4><pre># 모델 저장<br>path = &quot;./scann_model&quot;<br>tf.saved_model.save(<br>    retrieval_model,<br>    path,<br>    signatures={&#39;serving_default&#39;: retrieval_model.call}<br>)<br><br># 모델 로드<br>loaded_model = tf.saved_model.load(path)</pre><h4>tf-serving을 통한 서빙</h4><p>아래 Dockerfile을 사용해 AWS ECR 또는 Kubernetes 클러스터에 서빙할 수 있습니다.</p><pre>FROM google/tf-serving-scann:2.11.0<br>ENV MODEL_BASE_PATH={model_path}<br>ENV MODEL_NAME=scann_model</pre><h3>ScaNN 하이퍼파라미터 Rule-of-thumb</h3><ul><li>num_neighbors: 추론 시 필요한 TopK 개수.</li><li>num_leaves: 파티션 개수. 데이터 수의 제곱근으로 설정해 정확도와 추론 속도의 균형을 맞출 수 있습니다.</li><li>num_leaves_to_search: 추론 시 검색할 파티션 수. 값이 높을수록 정확도는 높아지나 성능이 감소할 수 있습니다.</li><li>데이터가 2만 미만일 경우 브루트포스, 10만 미만이면 비대칭 해싱(AH)과 재스코어링 사용, 10만 이상이면 파티셔닝+AH+재스코어링 사용.</li><li>AH 사용 시 dimensions_per_block은 2로 고정.</li><li>reordering_num_neighbors: 재정렬할 TopK 개수, num_neighbors보다 커야 합니다.</li></ul><h4>참고자료</h4><ul><li><a href="https://www.tensorflow.org/recommenders/api_docs/python/tfrs/layers/factorized_top_k/ScaNN">tfrs.layers.factorized_top_k.ScaNN | TensorFlow Recommenders</a></li><li><a href="https://github.com/google-research/google-research/blob/master/scann/docs/algorithms.md#rules-of-thumb">google-research/scann/docs/algorithms.md at master · google-research/google-research</a></li><li><a href="https://heegyukim.medium.com/%EC%B6%94%EC%B2%9C-%EC%8B%9C%EC%8A%A4%ED%85%9C-6-scann%EC%9D%84-%EC%9D%B4%EC%9A%A9%ED%95%9C-%EB%B2%A1%ED%84%B0-%EC%9C%A0%EC%82%AC%EB%8F%84-%EA%B2%80%EC%83%89-24b4cefe3eb9">추천 시스템 6 — ScaNN을 이용한 벡터 유사도 검색</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4253adced9d1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[[개발로그] CUDA_ERROR_SYSTEM_DRIVER_MISMATCH 이슈 해결]]></title>
            <link>https://chrisjune-13837.medium.com/%EA%B0%9C%EB%B0%9C%EB%A1%9C%EA%B7%B8-cuda-error-system-driver-mismatch-%EC%9D%B4%EC%8A%88-%ED%95%B4%EA%B2%B0-de8e47488b58?source=rss-e74406582b08------2</link>
            <guid isPermaLink="false">https://medium.com/p/de8e47488b58</guid>
            <category><![CDATA[cuda]]></category>
            <category><![CDATA[mlops]]></category>
            <category><![CDATA[nvidia]]></category>
            <dc:creator><![CDATA[chrisjune]]></dc:creator>
            <pubDate>Tue, 20 Aug 2024 06:20:35 GMT</pubDate>
            <atom:updated>2024-08-20T06:20:35.621Z</atom:updated>
            <content:encoded><![CDATA[<p>어느날 갑자기 잘 동작하던 학습 파이프라인에 아래와 같은 에러로 GPU장비를 사용할 수 없게 되었다.</p><pre>2024-08-19 01:32:26.558208: E external/local_xla/xla/stream_executor/cuda/cuda_driver.cc:274] failed call to cuInit: CUDA_ERROR_SYSTEM_DRIVER_MISMATCH: system has unsupported display driver / cuda driver combination<br>2024-08-19 01:32:26.558254: I external/local_xla/xla/stream_executor/cuda/cuda_diagnostics.cc:129] retrieving CUDA diagnostic information for host: example-server-850-2495792118-1213822419<br>2024-08-19 01:32:26.558265: I external/local_xla/xla/stream_executor/cuda/cuda_diagnostics.cc:136] hostname: example-server-850-2495792118-1213822419<br>2024-08-19 01:32:26.558382: I external/local_xla/xla/stream_executor/cuda/cuda_diagnostics.cc:159] libcuda reported version is: 550.54.15<br>2024-08-19 01:32:26.558409: I external/local_xla/xla/stream_executor/cuda/cuda_diagnostics.cc:163] kernel reported version is: 515.48.7<br>2024-08-19 01:32:26.558421: E external/local_xla/xla/stream_executor/cuda/cuda_diagnostics.cc:244] kernel version 515.48.7 does not match DSO version 550.54.15 -- cannot find working devices in this configuration<br>[name: &quot;/device:CPU:0&quot;</pre><h4>원인 (CUDA_ERROR_SYSTEM_DRIVER_MISMATCH)</h4><p>CUDA driver version과 display version이 다르다고 함. CUDA 드라이버 버전이 Display 드라이버 버전보다 높음.</p><h4>해결방안</h4><ol><li>Display driver 버전을 업그레이드하여 CUDA 버전과 호환성을 맞춘다</li><li>CUDA 버전을 다운그레이드한다.</li><li>kubenetes 환경이라면 CUDA버전에 맞는 GPU 장비를 스케줄링 하도록 pod nodeselector를 추가한다.</li></ol><p><strong>3–1) yaml에 affinity 정의</strong></p><pre>affinity:<br>  nodeAffinity:<br>    requiredDuringSchedulingIgnoredDuringExecution:<br>      nodeSelectorTerms:<br>        - matchExpressions:<br>          - key: nvidia.com/cuda.driver.major<br>            operator: In<br>            values:<br>              - 510<br>              - 515<br>              - 520</pre><p><strong>3–2) KFP 사용시 add_affinity 메서드로 정의</strong></p><pre>import kfp<br>from kfp import dsl<br><br>def my_pipeline():<br>    affinity = {<br>        &#39;nodeAffinity&#39;: {<br>            &#39;requiredDuringSchedulingIgnoredDuringExecution&#39;: {<br>                &#39;nodeSelectorTerms&#39;: [{<br>                    &#39;matchExpressions&#39;: [{<br>                        &#39;key&#39;: &#39;nvidia.com/cuda.driver.major&#39;,<br>                        &#39;operator&#39;: &#39;In&#39;,<br>                        &#39;values&#39;: [&#39;510&#39;, &#39;515&#39;, &#39;520&#39;]<br>                    }]<br>                }]<br>            }<br>        }<br>    }<br><br>    task = (dsl.ContainerOp(<br>        name=&#39;my-task&#39;,<br>        image=&#39;my-image:latest&#39;,<br>        command=[&#39;python&#39;, &#39;my_script.py&#39;],<br>        arguments=[&#39;arg1&#39;, &#39;arg2&#39;]<br>    )<br>    .add_affinity(affinity))<br><br>kfp.compiler.Compiler().compile(my_pipeline, &#39;pipeline.yaml&#39;)</pre><h4>용어정리</h4><p>display driver: 그래픽 드라이버, OS와 프로그램이 GPU를 사용할 수 있도록 해주는 프로그램. 여기서는 nvidia gpu 드라이버</p><p>kernel version: 여기서 말하는 kernel은 NVIDIA kernel 드라이버. NVIDIA 드라이버 패키지중 핵심부분이고 OS커널과 하드웨어와 상호 작용하는 드라이버의 일부임</p><p>libcuda version: CUDA toolkit의 버전을 의미</p><p>kernel driver version: NVIDIA kernel의 버전을 의미</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=de8e47488b58" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[[ML] Transformer Encoder 뽀개기]]></title>
            <link>https://chrisjune-13837.medium.com/ml-transformer-encoder-%EB%BD%80%EA%B0%9C%EA%B8%B0-4d10fb9b3bce?source=rss-e74406582b08------2</link>
            <guid isPermaLink="false">https://medium.com/p/4d10fb9b3bce</guid>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[tensorflow]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[chrisjune]]></dc:creator>
            <pubDate>Tue, 25 Jun 2024 08:50:07 GMT</pubDate>
            <atom:updated>2024-06-25T08:50:07.282Z</atom:updated>
            <content:encoded><![CDATA[<p>멀티헤드 어텐션 레이어를 활용한 Transformer encoder 구조를 만들어 봅니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oY0qEvV8krmcCIwQxliyOA.png" /><figcaption><a href="https://ssoldot.me/news/6461">https://ssoldot.me/news/6461</a></figcaption></figure><p>Attention에 대하여 궁금하신 분은 아래 링크글을 참고해주세요.</p><p><a href="https://chrisjune-13837.medium.com/ml-attention-%EB%A7%A4%EC%BB%A4%EB%8B%88%EC%A6%98-%EB%BD%80%EA%B0%9C%EA%B8%B0-277dcdbb3934">[ML] Attention 매커니즘 뽀개기</a></p><h3>Transformer Encoder</h3><p>멀티헤드 어텐션 레이어를 활용하여 트랜스포머 구조를 만들 수 있습니다.</p><pre>import tensorflow as tf<br>from tensorflow import keras<br>from tensorflow.keras import layers<br><br>class TransformerEncoder(layers.Layer):<br>    def __init__(self, embed_dim, dense_dim, num_heads, **kwargs):<br>        super().__init__(**kwargs)<br>        self.embed_dim = embed_dim # 입력토큰 크기<br>        self.dense_dim = dense_dim # dense<br>        self.num_heads = num_heads<br><br>        self.attention = layers.MultiHeadAttention(num_heads=num_heads, key_dim=embed_dim)<br>        self.dense_proj = keras.Sequential([<br>            layers.Dense(dense_dim, activation=&#39;relu&#39;),<br>            layers.Dense(embed_dim),])<br>        self.layernorm_1 = layers.LayerNormalization()<br>        self.layernorm_2 = layers.LayerNormalization()<br><br>    def call(self, inputs, mask=None):<br>        if mask is not None:<br>            mask = mask[:,tf.newaxis,:]<br>        attention_output = self.attention(<br>            inputs, inputs, attention_mask=mask)<br>        proj_input = self.layernorm_1(inputs + attention_output)<br>        proj_output = self.dense_proj(proj_input)<br>        return self.layernorm_2(proj_input + proj_output)<br>    def get_config(self):<br>        config = super().get_config()<br>        config.update({<br>            &quot;embed_dim&quot;: self.embed_dim,<br>            &quot;dense_dim&quot;: self.dense_dim,<br>            &quot;num_heads&quot;: self.num_heads<br>        })<br>        return config</pre><p>가장 기본형태의 트랜스포머 인코더입니다.문장의 토큰 임베딩을 입력받고 어텐션레이어를 통해 어텐션 가중치에 의해 조정되고, MLP 레이어와 정규화 레이어를 통과한 결과를 받습니다.</p><p>일반적으로 사용하는 BatchNormalization 이 아니라 LayerNormalization을 사용한 이유는 LayerNormalization은 마지막 축 따라서 평균과 분산을 구합니다. 예를 들어 (4,3,2) 형태의 벡터의 평균과 분산은 (4,3)이 되고 이를 활용해 정규화합니다. 각 시퀀스 안에서 데이터를 개별적으로 구하기 때문에 시퀀스 데이터에 적합합니다.</p><p>BatchNormalization은 마지막 축을 제외한 다른 축을 따라 평균과 분산을 구합니다. 예를 들어 (4,3,2) 형태의 벡터의 평균과 분산은 (2,) 형태가 되고 이를 활용해 정규화합니다. 보다 많은 데이터를 활용하기 때문에 특성의 평균과 분산에 대한 정확한 통계값을 구할 수 있습니다.</p><h3>PositionalEmbedding</h3><p>Transformer Encoder의 문제는 시퀀스에서 토큰의 순서를 바꾸어도 정확히 결과가 동일하다는 것입니다. 셀프어텐션은 원소 쌍 사이의 관계를 계산하기 때문에 순서를 고려하지 않습니다. I ate food과 Food ate I 는 다른 문장이기 때문에 순서를 고려할 수단이 필요합니다.</p><p>PositionalEmbedding은 시퀀스의 토큰 순서를 인식하기 위하여 시퀀스를 입력받아 String embedding과 위치 embedding을 생성합니다.</p><p>위치를 나타내는 방법으로는 시퀀스 특성상 주기를 표현할 수 있는 Cosine으로 -1과 1의 값으로 표현할 수 있습니다. 여기선 간단하게 토큰 순서대로 Incremental하게 숫자를 부여하는 방법을 사용했습니다.</p><pre>class PositionalEmbedding(layers.Layer):<br>    def __init__(self, sequence_length, input_dim, output_dim, **kwargs):<br>        super().__init__(**kwargs)<br>        self.token_embeddings = layers.Embedding(<br>            input_dim=input_dim, output_dim=output_dim)<br>        self.position_embeddings = layers.Embedding(<br>            input_dim=sequence_length, output_dim=output_dim)<br>        self.sequence_length = sequence_length<br>        self.input_dim=input_dim<br>        self.output_dim=output_dim<br>    <br>    def call(self, inputs):<br>        length = tf.shape(inputs)[-1]<br>        positions = tf.range(start=0, limit=length, delta=1)<br>        embedded_tokens = self.token_embeddings(inputs)<br>        embedded_position = self.position_embeddings(positions)<br>        return embedded_position + embedded_tokens<br><br>    def compute_mask(self, inputs, mask=None):<br>        return tf.math.not_equal(inputs, 0)<br><br>    def get_config(self):<br>        config = super().get_config()<br>        config.update({<br>            &quot;output_dim&quot;: self.output_dim,<br>            &quot;sequence_length&quot;: self.sequence_length,<br>            &quot;input_dim&quot;: self.input_dim<br>        })<br>        return config</pre><p>PositionalEmbedding과 TransformerEncoder를 활용하면 아래와 같은 Sequential Layer를 구성할 수 있습니다</p><pre>from keras import layers, Sequential<br><br>Sequential([<br>  layers.InputLayer(input_shape=(None,), dtype=tf.string),<br>  layers.StringLookup(vocabulary=lookup_vocab),<br>  PositionalEmbedding(sequence_length=50, input_dim=len(lookup_vocab) + 1, output_dim=embed_dim),<br>   TransformerEncoder(<br>     embed_dim=embed_dim,<br>     dense_dim=embed_dim,<br>     num_heads=num_heads,<br>  ),<br>  layers.GlobalAvgPool1D(),<br>  layers.Flatten()<br>]</pre><p>트랜스포머 Decoder과 이를 활용한 Sequence to Sequence 모델은 다른 포스트에서 정리하도록 하겠습니다.</p><p>간단하게 트랜스포머 인코더를 이해하시는데 조금이나마 도움이 되었으면 좋겠습니다.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4d10fb9b3bce" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[[ML] Attention 매커니즘 뽀개기]]></title>
            <link>https://chrisjune-13837.medium.com/ml-attention-%EB%A7%A4%EC%BB%A4%EB%8B%88%EC%A6%98-%EB%BD%80%EA%B0%9C%EA%B8%B0-277dcdbb3934?source=rss-e74406582b08------2</link>
            <guid isPermaLink="false">https://medium.com/p/277dcdbb3934</guid>
            <category><![CDATA[deep-learning]]></category>
            <category><![CDATA[tensorflow]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[machine-learning]]></category>
            <dc:creator><![CDATA[chrisjune]]></dc:creator>
            <pubDate>Tue, 25 Jun 2024 08:37:49 GMT</pubDate>
            <atom:updated>2024-06-25T08:37:49.086Z</atom:updated>
            <content:encoded><![CDATA[<p>어텐션과 어텐션 메커니즘에하여 알아봅니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-sN239ocWT4XoOIbY7JDTw.png" /><figcaption><a href="https://www.youtube.com/@K.Musicz">https://www.youtube.com/@K.Musicz</a></figcaption></figure><h3>사전 지식</h3><p><strong>토큰</strong><br>일반적인 문장은 모델에서 학습하기 어렵기 때문에 전처리 과정을 거칩니다. 이 과정속에서 대/소문자 변환, 형변환, 구두점 처리를 하고 무엇보다 단어의 형태로 자릅니다. 이 단어를 토큰이라고 부릅니다.</p><p><strong>임베딩</strong><br>텍스트 데이터를 수치데이터로 변환하는 것을 의미합니다. 이름에서 의미하는 것처럼 고차원인 텍스트를 저차원의 벡터공간에 “끼워넣는”것을 의미합니다. 예를 들어 station을 임베딩 변환하면 [0.1, 0.6]과 같은 벡터공간에 표현할 수 있습니다.</p><h3>어텐션</h3><p>어텐션이란, 각 토큰이 다른 토큰에게 얼마나 관심있는지를 의미합니다. 관심 정도를 알기 위하여 관심도를 점수로 계산하는데 이를 어텐션 스코어라고 부릅니다.</p><p>셀프 어텐션이란, 어텐션 스코어로 원본 토큰을 갱신하는 것을 의미합니다. 다른 말로 어텐션 스코어로 가중합(Weighted sum)했다고 표현하기도 합니다. 예를 들어 “The train left the station on time.” 문장에서 Station은 그 자체로는 (우주)정거장인지, (버스)정거장인지, 어떤 정거장인지 알 길이 없습니다. 이를 알기 위해 다른 토큰들간의 관심도인 어텐션 스코어를 계산합니다. 그 후 어텐션 스코어로 원본 토큰을 가중합하면 갱신된 토큰이 됩니다. 갱신후엔 (기차)정거장 이라는 의미가 반영된 Station으로 변하게 됩니다.</p><p>극단적으로 표현하면 아래의 그림과 같습니다. 기존 토큰 임베딩은 토큰간의 관계가 고정되었지만, 어텐션은 단어간 관계를 서로 유기적으로 조정하여 갱신합니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4sDjIDe1oW-TJIpcsfEdBw.png" /></figure><h3>어텐션 스코어 계산</h3><p>어텐션이란, 토큰간 관심도를 의미하고, 어텐션 스코어는 토큰간 관심도를 계산한 점수이며, 이를 통해 토큰을 Update하는 것을 셀프어텐션이라고 설명드렸습니다. 셀프 어텐션을 진행하면 각 모든 토큰들간 스코어를 계산하고 모든 토큰들의 값이 변경됩니다.</p><p>아래 예시 코드를 따라 어텐션에 대하여 알아보겠습니다.</p><h4><strong>1. 문장 임베딩.</strong></h4><p>입력받은 문장을 임베딩하여 모델에 주입할 수 있도록 변환해줍니다.</p><pre>import tensorflow as tf<br>import numpy as np<br><br># 원본문장<br>sentence = np.array([&quot;the&quot;, &quot;train&quot;, &quot;station&quot;, &quot;left&quot;, &quot;the&quot;, &quot;station&quot;, &quot;on&quot;, &quot;time&quot;])<br># 임베딩<br>lookup = tf.keras.layers.StringLookup(vocabulary=np.unique(sentence))<br>emb = tf.keras.layers.Embedding(len(np.unique(sentence))+1, 3)<br># 출력<br>print(emb(lookup(sentence)).numpy())</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zTMXID7z2pV345W5nGADNg.png" /></figure><h4>2. 어텐션 스코어 matrix 계산</h4><p>어텐션 점수는 Dot product로 토큰 벡터간 연관도를 계산할 수 있습니다. 이후 np.sqrt(nums of embedding dims)로 나눠주고 softmax 해준 결과입니다.</p><pre>def softmax(x):<br>    return np.exp(x)/sum(np.exp(x))<br><br>num_emb_dims = 3<br>matrix = softmax(np.dot(token, token.T)/np.sqrt(num_emb_dims))<br>pd.DataFrame(matrix)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U1yzu5KLdvt7WCqZ6PCSXA.png" /></figure><h4><strong>3. 어텐션 스코어 plotting</strong></h4><p>아직 학습이 되기 전의 임베딩이라 플로팅을 했을때 인사이트를 얻을 순 없는데, 학습이 진행되고 나면 대각성분과 관심도가 높은 토큰간 색이 짙게 표현됩니다.</p><pre>import numpy as np<br>import matplotlib.pyplot as plt<br><br>fig, ax = plt.subplots()<br>cax = ax.imshow(matrix, cmap=&#39;hot_r&#39;, interpolation=&#39;nearest&#39;)  # Using reversed hot colormap<br>fig.colorbar(cax)<br><br># Set the ticks and labels for both axes<br>words = [&quot;the&quot;, &quot;train&quot;, &quot;left&quot;, &quot;the&quot;, &quot;station&quot;, &quot;on&quot;, &quot;time&quot;]<br>ax.set_xticks(np.arange(len(words)))<br>ax.set_yticks(np.arange(len(words)))<br>ax.set_xticklabels(words)<br>ax.set_yticklabels(words)<br><br># Rotate the tick labels for x-axis to avoid overlapping<br>plt.setp(ax.get_xticklabels(), rotation=45, ha=&quot;right&quot;, rotation_mode=&quot;anchor&quot;)<br><br>plt.show()</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GzFcr84w5cdrvr76YBx3Sw.png" /></figure><h4><strong>4. 셀프 어텐션 후 갱신된 토큰 계산.</strong></h4><p>3번에서 계산된 어텐션 스코어를 원본 토큰에 가중합을 하면 셀프어텐션 결과를 얻을 수 있습니다.</p><pre>new_token = []<br>for pivot in range(matrix.shape[0]):<br>    new_token.append(np.sum(token * np.expand_dims(matrix[:,pivot], axis=1), axis=0))<br>pd.DataFrame(new_token)</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1VAI1atkTZFdjDERjJkPkg.png" /></figure><p>0번째 토큰으로 자세히 설명해보면 0번째 토큰의 어텐션 스코어를 기준으로 원본 토큰 임베딩에 element-wise 곱을 하고, 샘플 축을 따라 더하면 새로운 토큰이 계산됩니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*uvqqBBnqC2vKSNjOrUgIsA.png" /></figure><p>의사코드로 표현하면 아래와 같습니다.</p><pre>def self_attention(input_sequence):<br>    output = np.zeros(shape=input_sequence.shape)<br>    for i, pivot_vector in enumerate(input_sequence):<br>        scores = np.zeros(shape=(len(input_sequence),))<br>        for j, vector in enumerate(input_sequence):<br>            dot_result = np.dot(pivot_vector, vector.T) # 어텐션 계산<br>            scores[j] = dot_result<br>            matrix[i][j] = dot_result<br>        scores /= np.sqrt(input_sequence.shape[1])<br>        scores = softmax(scores)<br><br>        new_pivot_representation = np.zeros(shape=pivot_vector.shape)<br>        for j, vector in enumerate(input_sequence):<br>            new_pivot_representation += vector * scores[j] # 셀프 어텐션<br>        output[i] = new_pivot_representation<br>    return output</pre><h3>어텐션 레이어</h3><p>일반적인 어텐션레이어는 그림과 같습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*swURMtXbiz1rsdW7XPpV2A.png" /></figure><p>보통의 레이어에서 입력이 1개지만 어텐션 레이어에서는 3개의 입력을 받습니다. 그 이유는 어텐션 메커니즘에서 입력이 세개이기 때문입니다. 의사코드를 한줄로 표현하면 아래와 같은데요.</p><pre>outputs = sum(inputs * pairwise_score(inputs, inputs))</pre><p>inputs이 세번 사용되는데, 모두 같을 필요가 없습니다.</p><pre>outputs = sum(values * pairwise_score(query, key))</pre><p>inputs들의 이름을 달리하면 Query, Key, Value라고 부릅니다.</p><p><strong>쿼리(Query)</strong>는 현재 처리 중인 입력 요소에 대한 정보를 담고 있습니다. 이는 어텐션을 구할 때 “어떤 정보를 찾고 있는가?”에 해당하는 역할을 합니다.</p><p><strong>키(Key)</strong>는 입력 시퀀스의 각 요소에 대한 식별자 역할을 합니다. 키는 각 요소가 다른 요소들과 비교될 때 사용되며, “어디에서 찾을 것인가?”에 해당하는 역할을 합니다.</p><p><strong>값(Value)</strong>은 실제로 검색되고 나서 반환될 정보입니다. 이는 어텐션 메커니즘이 선택한 정보를 바탕으로 최종 출력값을 생성할 때 사용됩니다. “찾은 정보는 무엇인가?”에 해당합니다.</p><p>일반적으로 키와 값이 같은 경우가 많고 아래와 같은 상황에 따라 다르기도 합니다.</p><ul><li>검색 시스템: 쿼리: 검색어 / 키: 상품마다 정의된 검색 키워드 (검색어 사전) / 값: 상품자체</li><li>번역: 쿼리: 번역된 문장 / 키: 번역할 문장 / 값: 번역할 문장</li><li>문장 분류: 쿼리, 키, 값 모두 동일</li></ul><h3>멀티헤드 어텐션 레이어</h3><p>입력 어텐션 레이어가 두개 이상인 것을 멀티헤드라고 부릅니다. <br>쿼리, 키, 값은 각각의 Dense layer를 통해 독립적인 백터가 됩니다. 여러 개의 어텐션 메커니즘(헤드)을 병렬로 사용하여 서로 다른 부분의 정보를 동시에 학습합니다. 이를 통해 모델은 다양한 관점에서 데이터를 분석할 수 있게 됩니다. CNN 구조에서 커널의 개수를 늘릴 수록 병렬로 학습하여 표현력을 높이는것과 유사합니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2m5xBXIdddgPNdOBijzZ7Q.png" /></figure><p>트랜스포머 인코더와 디코더를 활용한 Seq2Seq 모델은 다른 포스트에서 정리하겠습니다. 어텐션과 어텐션 매커니즘을 이해하는데 조금이나마 도움이 되었으면 좋겠습니다.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=277dcdbb3934" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>