<?xml version="1.0" encoding="utf-8"?><?xml-stylesheet type="text/xsl" href="atom.xsl"?>
<feed xmlns="http://www.w3.org/2005/Atom">
    <id>https://ql.gl/ko/blog/</id>
    <title>p4r4d0xb0x Blog</title>
    <updated>2026-08-19T00:00:00.000Z</updated>
    <generator>https://github.com/jpmonette/feed</generator>
    <link rel="alternate" href="https://ql.gl/ko/blog/"/>
    <subtitle>p4r4d0xb0x Blog</subtitle>
    <icon>https://ql.gl/ko/img/favicon.ico</icon>
    <entry>
        <title type="html"><![CDATA[S4: 긴 시퀀스를 구조화된 상태공간으로 읽는 법]]></title>
        <id>https://ql.gl/ko/blog/4a6889f1/</id>
        <link href="https://ql.gl/ko/blog/4a6889f1/"/>
        <updated>2026-08-19T00:00:00.000Z</updated>
        <summary type="html"><![CDATA[Structured State Space sequence model(S4)이 긴 의존성을 다루기 위해 상태공간모델을 어떻게 구조화하고, 계산 가능한 Cauchy 커널로 바꾸는지 살펴봅니다. arXiv 초록과 메타데이터에서 확인되는 주장만 구분해 정리합니다.]]></summary>
        <content type="html"><![CDATA[<p>긴 시퀀스 모델링의 병목은 단순히 “토큰이 많다”는 데 있지 않습니다. 먼 과거의 신호를 현재 출력에 전달하면서도, 학습 시 병렬성을 유지하고 추론 시 메모리 이동을 감당해야 합니다. <strong>Efficiently Modeling Long Sequences with Structured State Spaces</strong>는 이 문제를 상태공간모델(SSM)의 수학적 성질과 계산 구조를 함께 다루는 방식으로 풀려는 논문입니다. 핵심은 SSM 전체를 무작정 계산하는 것이 아니라, 상태 행렬을 구조화해 안정적으로 대각화하고 Cauchy 커널 계산으로 환원하는 것입니다.</p>
<p><img decoding="async" loading="lazy" src="https://ql.gl/img/blog/s4-structured-state-spaces/cover.webp" alt="긴 입력 시퀀스가 구조화된 상태공간과 커널 계산으로 변환되는 개념도" class="img_ev3q"></p>
<p>이 글은 arXiv 공개 초록과 API 메타데이터를 근거로 합니다. 초록에 명시된 수치와 구성은 “논문이 보고한 결과”로 표현하며, 세부 하이퍼파라미터·코드 구현·전체 실험 절차는 확인하지 않은 범위로 남겨 둡니다.</p>
<!-- -->
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="문제-긴-의존성과-계산-비용의-동시성">문제: 긴 의존성과 계산 비용의 동시성<a href="https://ql.gl/ko/blog/4a6889f1/#%EB%AC%B8%EC%A0%9C-%EA%B8%B4-%EC%9D%98%EC%A1%B4%EC%84%B1%EA%B3%BC-%EA%B3%84%EC%82%B0-%EB%B9%84%EC%9A%A9%EC%9D%98-%EB%8F%99%EC%8B%9C%EC%84%B1" class="hash-link" aria-label="문제: 긴 의존성과 계산 비용의 동시성에 대한 직접 링크" title="문제: 긴 의존성과 계산 비용의 동시성에 대한 직접 링크" translate="no">​</a></h2>
<p>RNN, CNN, Transformer는 각각 긴 의존성을 다루는 변형을 갖지만, 논문은 10,000스텝 이상으로 매우 긴 시퀀스에서 기존 접근이 확장하기 어렵다고 문제를 제기합니다. 특히 Transformer의 전역 attention은 입력 길이에 따라 계산과 메모리 부담이 커지고, 일반적인 SSM도 수학적으로는 긴 의존성을 표현할 수 있어도 실제 계산·메모리 요구량이 너무 커질 수 있습니다.</p>
<p>연속시간 SSM은 다음과 같이 표현됩니다.</p>
<p>[
x'(t)=Ax(t)+Bu(t), \qquad y(t)=Cx(t)+Du(t)
]</p>
<p>여기서 입력 (u)가 내부 상태 (x)를 갱신하고, 출력 (y)는 상태의 관측값이 됩니다. 이 표현은 긴 신호를 압축된 상태로 누적한다는 직관을 주지만, 상태 차원이 크면 행렬 연산이 곧 병목이 됩니다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 상태공간모델(SSM)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 시간에 따라 변하는 내부 상태를 조금씩 갱신하면서 긴 입력을 처리하는 모델입니다.</p><p>예시: 일기장 전체를 매번 다시 읽는 대신, 오늘까지의 중요한 내용을 메모 한 장에 계속 요약해 두고 다음 날의 판단에 사용하는 방식과 비슷합니다.</p></div></div>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="s4의-핵심-상태-행렬을-구조화하기">S4의 핵심: 상태 행렬을 구조화하기<a href="https://ql.gl/ko/blog/4a6889f1/#s4%EC%9D%98-%ED%95%B5%EC%8B%AC-%EC%83%81%ED%83%9C-%ED%96%89%EB%A0%AC%EC%9D%84-%EA%B5%AC%EC%A1%B0%ED%99%94%ED%95%98%EA%B8%B0" class="hash-link" aria-label="S4의 핵심: 상태 행렬을 구조화하기에 대한 직접 링크" title="S4의 핵심: 상태 행렬을 구조화하기에 대한 직접 링크" translate="no">​</a></h2>
<p>S4는 SSM의 상태 행렬 (A)에 구조를 부여하는 새로운 파라미터화를 제안합니다. 초록이 강조하는 구체적 장치는 <strong>low-rank correction</strong>, 즉 저랭크 보정입니다. 이를 이용하면 (A)를 안정적으로 대각화할 수 있고, 결과적으로 SSM의 계산을 잘 연구된 Cauchy 커널 계산으로 줄일 수 있다고 설명합니다.</p>
<p>이 설계는 두 층의 문제를 분리합니다. 첫째는 어떤 상태 행렬이 장거리 의존성을 표현할 수 있는가입니다. 둘째는 그 행렬을 현대 하드웨어에서 실제로 계산할 수 있는가입니다. S4의 기여는 이론적 표현력을 유지하면서도 두 번째 문제를 계산 커널 수준에서 다루려는 시도로 읽을 수 있습니다. 다만 “효율적”이라는 말은 특정 구현과 하드웨어, 시퀀스 길이의 조건에 의존하므로 일반적인 우월성으로 확대해서는 안 됩니다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 저랭크 보정(low-rank correction)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 큰 행렬 전체를 바꾸지 않고, 소수의 방향만 추가해 구조를 조정하는 방법입니다.</p><p>예시: 도서관의 모든 책장을 다시 만들지 않고, 자주 찾는 몇 개의 통로에 안내판을 추가해 전체 탐색을 빠르게 만드는 것과 같습니다.</p></div></div>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: Cauchy 커널</div><div class="admonitionContent_BuS1"><p>쉬운정의: 특정한 두 값의 차이를 이용해 행렬 계산을 빠르게 표현하는 수학적 계산 형태입니다.</p><p>예시: 사람마다 일일이 거리를 재는 대신, 좌표 목록에 같은 계산 규칙을 적용해 여러 쌍의 관계를 한 번에 계산하는 방식으로 이해할 수 있습니다.</p></div></div>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="논문-구조-분석과-보고된-결과">논문 구조 분석과 보고된 결과<a href="https://ql.gl/ko/blog/4a6889f1/#%EB%85%BC%EB%AC%B8-%EA%B5%AC%EC%A1%B0-%EB%B6%84%EC%84%9D%EA%B3%BC-%EB%B3%B4%EA%B3%A0%EB%90%9C-%EA%B2%B0%EA%B3%BC" class="hash-link" aria-label="논문 구조 분석과 보고된 결과에 대한 직접 링크" title="논문 구조 분석과 보고된 결과에 대한 직접 링크" translate="no">​</a></h2>
<p>초록의 논리 흐름은 문제 제기 → 기본 SSM의 가능성과 병목 → S4의 구조적 제안 → 다양한 벤치마크 결과 순서입니다. 이는 문제-갭-기여-검증으로 이어지는 전형적인 연구 서사입니다. 제공된 초록만으로는 본문이 IMRaD의 어느 세부 변형을 취했는지, 각 실험의 베이스라인과 하드웨어 설정이 무엇인지까지 확정할 수 없습니다.</p>
<p>논문이 초록에서 보고한 결과는 다음과 같습니다.</p>
<ul>
<li class="">데이터 증강이나 보조 손실 없이 sequential CIFAR-10에서 91% 정확도를 달성했으며, 더 큰 2-D ResNet과 비슷한 수준이라고 주장합니다.</li>
<li class="">이미지 및 언어 모델링에서 Transformer와의 격차를 크게 줄였고, 생성은 60배 빠르다고 보고합니다. 이 수치는 작업·구현 조건이 함께 확인되어야 의미를 해석할 수 있습니다.</li>
<li class="">Long Range Arena의 모든 과제에서 당시 최고 성능을 기록했으며, 길이 16k의 Path-X를 해결했다고 초록은 설명합니다.</li>
</ul>
<p>이 결과는 S4가 단일 작업용 트릭이 아니라 여러 모달리티의 긴 의존성을 겨냥한 범용 계열임을 보여주는 근거입니다. 반대로, 초록만으로는 재현성, 에너지 비용, 메모리 사용량, 오늘날의 모델과의 비교를 판단할 수 없습니다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="실무적-함의-선형성보다-커널과-상태가-중요하다">실무적 함의: 선형성보다 커널과 상태가 중요하다<a href="https://ql.gl/ko/blog/4a6889f1/#%EC%8B%A4%EB%AC%B4%EC%A0%81-%ED%95%A8%EC%9D%98-%EC%84%A0%ED%98%95%EC%84%B1%EB%B3%B4%EB%8B%A4-%EC%BB%A4%EB%84%90%EA%B3%BC-%EC%83%81%ED%83%9C%EA%B0%80-%EC%A4%91%EC%9A%94%ED%95%98%EB%8B%A4" class="hash-link" aria-label="실무적 함의: 선형성보다 커널과 상태가 중요하다에 대한 직접 링크" title="실무적 함의: 선형성보다 커널과 상태가 중요하다에 대한 직접 링크" translate="no">​</a></h2>
<p>S4에서 배울 실무적 관점은 “복잡도가 낮다”는 문구보다 <strong>계산 경로가 하드웨어에서 어떻게 실행되는가</strong>를 먼저 보라는 점입니다. 긴 입력을 상태로 누적하는 모델은 attention의 명시적 토큰 쌍 비교를 줄일 수 있지만, 상태 업데이트·커널 생성·메모리 배치가 병목이 될 수 있습니다. 따라서 도입 전에는 다음을 측정해야 합니다.</p>
<ul>
<li class="">학습과 추론을 분리한 실제 처리량과 지연시간</li>
<li class="">시퀀스 길이에 따른 메모리 사용량과 커널 실행 시간</li>
<li class="">상태 차원과 배치 크기 변화에 따른 품질·비용 곡선</li>
<li class="">긴 과거 정보를 보존해야 하는 업무에서의 실패 유형</li>
</ul>
<p>이 관점은 이후 SSM 연구가 “표현력”과 “하드웨어 활용”을 함께 최적화하게 된 배경과도 연결됩니다. 그러나 S4 자체가 모든 장거리 정보 검색 문제를 해결한다는 뜻은 아닙니다. 모델이 정보를 어떤 상태에 압축하는지, 충돌하는 신호를 어떻게 구별하는지는 별도 평가가 필요합니다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="한계와-확인이-필요한-질문">한계와 확인이 필요한 질문<a href="https://ql.gl/ko/blog/4a6889f1/#%ED%95%9C%EA%B3%84%EC%99%80-%ED%99%95%EC%9D%B8%EC%9D%B4-%ED%95%84%EC%9A%94%ED%95%9C-%EC%A7%88%EB%AC%B8" class="hash-link" aria-label="한계와 확인이 필요한 질문에 대한 직접 링크" title="한계와 확인이 필요한 질문에 대한 직접 링크" translate="no">​</a></h2>
<p>제공된 자료에서 확인되는 범위는 논문의 초록과 공개 메타데이터입니다. 따라서 다음은 미확인입니다. 저랭크 보정의 정확한 파라미터화와 안정성 조건, Cauchy 커널의 구체적 구현, 각 벤치마크의 하드웨어·베이스라인·측정 방식, 60배 생성 속도의 비교 조건, 그리고 실패 사례입니다. 특히 “모든 과제에서 SoTA” 같은 시점 의존적 표현은 논문 발표 당시의 결과이지 현재의 보편적 순위가 아닙니다.</p>
<p>실제 도입 전에는 원문 본문과 코드, 재현 벤치마크를 확인해야 합니다. S4의 설계는 매력적이지만, 긴 시퀀스의 품질이 필요한 시스템에서는 평균 점수보다 최악 길이와 정보 손실 패턴을 먼저 검증하는 편이 안전합니다.</p>
<p>또 하나의 실무 질문은 상태의 수명입니다. 배치 추론에서는 각 샘플의 상태를 명확히 분리해야 하고, 스트리밍에서는 다음 청크로 넘길 상태와 요청이 끝날 때 폐기할 상태를 구분해야 합니다. 이 경계가 흐려지면 모델의 수학적 안정성과 별개로 이전 입력의 정보가 다음 요청에 섞일 수 있습니다. 논문 초록은 이런 서비스 운영 문제를 다루지 않으므로, S4를 제품에 연결하는 단계에서 별도 설계가 필요합니다.</p>
<p>S4를 평가할 때는 긴 입력을 한 번에 넣는 벤치마크와 실제 청크 단위 스트리밍을 나누는 것도 유용합니다. 같은 모델이라도 전체 시퀀스 병렬 학습 경로와 순차 추론 경로의 비용 구조가 다를 수 있기 때문입니다. 이 구분이 있어야 논문에서 말하는 커널 효율과 실제 애플리케이션의 지연시간을 혼동하지 않을 수 있습니다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="sources">Sources<a href="https://ql.gl/ko/blog/4a6889f1/#sources" class="hash-link" aria-label="Sources에 대한 직접 링크" title="Sources에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class=""><a href="https://arxiv.org/abs/2111.00396" target="_blank" rel="noopener noreferrer" class="">Efficiently Modeling Long Sequences with Structured State Spaces</a> — license: <code>unknown</code>, retrieved: <code>2026-08-19</code>, source type: <code>original</code>.</li>
<li class="">Image: <a href="https://arxiv.org/abs/2111.00396" target="_blank" rel="noopener noreferrer" class="">Placeholder — 원문 기반 커버 이미지 미제작</a> — license: <code>unknown-placeholder</code>.</li>
</ul>]]></content>
        <author>
            <name>p4r4d0xb0x</name>
            <uri>https://bdev.io</uri>
        </author>
        <category label="AI" term="AI"/>
        <category label="Research" term="Research"/>
        <category label="Sequence Modeling" term="Sequence Modeling"/>
        <category label="SSM" term="SSM"/>
        <category label="Explainer" term="Explainer"/>
    </entry>
    <entry>
        <title type="html"><![CDATA[H3: 언어 모델링에서 SSM이 놓치던 기억과 비교]]></title>
        <id>https://ql.gl/ko/blog/7ecdd9d9/</id>
        <link href="https://ql.gl/ko/blog/7ecdd9d9/"/>
        <updated>2026-08-19T00:00:00.000Z</updated>
        <summary type="html"><![CDATA[Hungry Hungry Hippos가 상태공간모델의 언어적 약점을 토큰 기억과 비교 능력으로 분해하고, H3와 FlashConv, 하이브리드 attention 조합으로 어떻게 보완하는지 설명합니다.]]></summary>
        <content type="html"><![CDATA[<p>상태공간모델(SSM)은 시퀀스 길이에 대해 거의 선형으로 확장될 수 있지만, 그것만으로 언어 모델링에서 attention을 대체하지는 못합니다. <strong>Hungry Hungry Hippos: Towards Language Modeling with State Space Models</strong>는 이 격차를 막연한 표현력 부족으로 묶지 않고 두 기능으로 나눕니다. 기존 SSM이 앞선 토큰을 정확히 회상하는 일과 시퀀스 안의 토큰을 서로 비교하는 일에 약하다는 것입니다. 이 논문은 그 진단 위에 H3 계층과 FlashConv 계산법, 그리고 일부 attention을 남긴 하이브리드 모델을 제안합니다.</p>
<p><img decoding="async" loading="lazy" src="https://ql.gl/img/blog/h3-language-ssm/cover.webp" alt="언어 시퀀스의 토큰 기억과 비교를 H3 상태공간 계층으로 표현한 개념도" class="img_ev3q"></p>
<p>이 글은 arXiv 초록과 공개 메타데이터만을 근거로 합니다. 아래의 수치와 모델 규모는 논문 초록이 보고한 결과이며, 세부 실험 설정과 구현 재현성은 원문 본문 확인이 필요합니다.</p>
<!-- -->
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="문제를-두-가지-능력으로-분해하기">문제를 두 가지 능력으로 분해하기<a href="https://ql.gl/ko/blog/7ecdd9d9/#%EB%AC%B8%EC%A0%9C%EB%A5%BC-%EB%91%90-%EA%B0%80%EC%A7%80-%EB%8A%A5%EB%A0%A5%EC%9C%BC%EB%A1%9C-%EB%B6%84%ED%95%B4%ED%95%98%EA%B8%B0" class="hash-link" aria-label="문제를 두 가지 능력으로 분해하기에 대한 직접 링크" title="문제를 두 가지 능력으로 분해하기에 대한 직접 링크" translate="no">​</a></h2>
<p>논문은 먼저 synthetic language modeling task를 통해 SSM과 attention 사이의 표현력 격차를 조사했다고 설명합니다. 그 결과 기존 SSM이 어려워한 것은 두 가지였습니다.</p>
<ol>
<li class=""><strong>앞서 나온 토큰을 회상하기</strong> — 현재 예측에 필요한 특정 과거 토큰을 상태에 보존해야 합니다.</li>
<li class=""><strong>토큰을 비교하기</strong> — 현재 토큰과 시퀀스 속 다른 토큰의 관계를 계산해야 합니다.</li>
</ol>
<p>이 분해가 중요한 이유는 “긴 의존성”을 하나의 숫자로 취급하지 않게 해주기 때문입니다. 장거리 신호가 있다는 사실과, 그중 특정 항목을 찾아 비교해야 한다는 사실은 다릅니다. SSM의 압축 상태는 전자의 누적에는 적합할 수 있어도 후자의 선택적 상호작용에는 다른 구조가 필요할 수 있습니다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 표현력(expressivity)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 모델이 입력에서 구별하고 기억해 낼 수 있는 패턴의 범위입니다.</p><p>예시: 요약 노트가 전체 줄거리는 담아도, 20쪽에 나온 특정 단어와 80쪽의 단어가 같은지까지 답하지 못할 수 있습니다. 그 차이가 표현력의 문제입니다.</p></div></div>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="h3-회상과-비교를-의도적으로-설계하기">H3: 회상과 비교를 의도적으로 설계하기<a href="https://ql.gl/ko/blog/7ecdd9d9/#h3-%ED%9A%8C%EC%83%81%EA%B3%BC-%EB%B9%84%EA%B5%90%EB%A5%BC-%EC%9D%98%EB%8F%84%EC%A0%81%EC%9C%BC%EB%A1%9C-%EC%84%A4%EA%B3%84%ED%95%98%EA%B8%B0" class="hash-link" aria-label="H3: 회상과 비교를 의도적으로 설계하기에 대한 직접 링크" title="H3: 회상과 비교를 의도적으로 설계하기에 대한 직접 링크" translate="no">​</a></h2>
<p>H3는 언어에서 필요한 두 능력을 목표로 새롭게 설계한 SSM 계층입니다. 초록은 H3가 synthetic language에서 attention과 맞먹고, OpenWebText에서 Transformer와 0.4 PPL 이내까지 접근했다고 보고합니다. 여기서 중요한 것은 H3가 단순히 더 큰 상태를 쓰는 접근으로 소개되지 않는다는 점입니다. 논문의 설명상, 어떤 정보를 보존하고 어떤 관계를 계산할지라는 언어적 요구를 계층 설계에 반영합니다.</p>
<p>다만 초록은 H3 내부의 모든 게이트·분기·파라미터식과 각 구성요소의 기여도를 제공하지 않습니다. 따라서 이 글에서는 “회상과 비교를 위해 설계된 SSM layer”라는 수준을 넘는 내부 구현을 단정하지 않습니다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: PPL(perplexity)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 언어 모델이 다음 토큰을 얼마나 자신 있게 예측하는지 나타내는 지표로, 보통 낮을수록 좋습니다.</p><p>예시: 빈칸 채우기에서 가능한 답을 한두 개로 좁혀 확신 있게 맞히면 낮고, 수십 개를 망설이면 높은 점수가 나오는 방식입니다.</p></div></div>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="flashconv-알고리즘과-하드웨어-사이">FlashConv: 알고리즘과 하드웨어 사이<a href="https://ql.gl/ko/blog/7ecdd9d9/#flashconv-%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98%EA%B3%BC-%ED%95%98%EB%93%9C%EC%9B%A8%EC%96%B4-%EC%82%AC%EC%9D%B4" class="hash-link" aria-label="FlashConv: 알고리즘과 하드웨어 사이에 대한 직접 링크" title="FlashConv: 알고리즘과 하드웨어 사이에 대한 직접 링크" translate="no">​</a></h2>
<p>논문이 지적하는 두 번째 장벽은 하드웨어 활용입니다. SSM은 길이에 대해 거의 선형이어도 Transformer보다 느릴 수 있습니다. 계산량의 점근식만으로는 실제 실행 시간을 설명할 수 없기 때문입니다. H3 논문은 FlashConv를 제안해 최대 8K 길이에서 fused block FFT 알고리즘을 사용하고, 더 긴 입력에는 SSM의 recurrent 성질을 활용하는 state passing 알고리즘을 도입했다고 초록에서 설명합니다.</p>
<p>그 결과 초록은 Long Range Arena에서 2배 속도 향상을, 하이브리드 언어 모델의 생성에서는 Transformer 대비 2.4배 빠른 결과를 보고합니다. 이 수치는 “모든 환경에서 2배”가 아니라 논문이 측정한 벤치마크와 구현 조건의 결과입니다. 실제 서비스라면 GPU 세대, 배치, 정밀도, 커널 지원, 입출력 길이를 함께 고정해 비교해야 합니다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: fused kernel</div><div class="admonitionContent_BuS1"><p>쉬운정의: 여러 계산 단계를 따로 실행하지 않고 하나의 하드웨어 커널로 합쳐 메모리 왕복을 줄이는 구현입니다.</p><p>예시: 재료를 도마에 올렸다가 그릇으로 여러 번 옮기는 대신, 한 번에 섞어 조리하는 것과 비슷합니다.</p></div></div>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="하이브리드-모델이-주는-신호">하이브리드 모델이 주는 신호<a href="https://ql.gl/ko/blog/7ecdd9d9/#%ED%95%98%EC%9D%B4%EB%B8%8C%EB%A6%AC%EB%93%9C-%EB%AA%A8%EB%8D%B8%EC%9D%B4-%EC%A3%BC%EB%8A%94-%EC%8B%A0%ED%98%B8" class="hash-link" aria-label="하이브리드 모델이 주는 신호에 대한 직접 링크" title="하이브리드 모델이 주는 신호에 대한 직접 링크" translate="no">​</a></h2>
<p>흥미로운 결과는 attention을 전부 제거하지 않은 125M 파라미터 H3-attention 모델입니다. 초록에 따르면 attention 층 두 개를 유지한 이 모델은 OpenWebText에서 Transformer보다 1.0 PPL 낮았습니다. 또한 FlashConv를 사용해 Pile에서 최대 2.7B 파라미터까지 확장했고, SuperGLUE의 다수 과제에서 zero-shot·few-shot 평가로 Transformer를 앞섰다고 보고합니다.</p>
<p>이 결과는 SSM 대 Transformer의 이분법보다 역할 분담이 현실적일 수 있음을 시사합니다. SSM이 긴 흐름을 효율적으로 전달하고, 소수의 attention 층이 명시적 비교와 선택을 담당하는 식입니다. 그러나 어떤 층에 attention을 배치해야 하는지, 다른 데이터·모델 크기·하드웨어에서도 같은 이점이 나는지는 초록만으로 답할 수 없습니다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="논문-구조-분석-진단에서-시스템까지">논문 구조 분석: 진단에서 시스템까지<a href="https://ql.gl/ko/blog/7ecdd9d9/#%EB%85%BC%EB%AC%B8-%EA%B5%AC%EC%A1%B0-%EB%B6%84%EC%84%9D-%EC%A7%84%EB%8B%A8%EC%97%90%EC%84%9C-%EC%8B%9C%EC%8A%A4%ED%85%9C%EA%B9%8C%EC%A7%80" class="hash-link" aria-label="논문 구조 분석: 진단에서 시스템까지에 대한 직접 링크" title="논문 구조 분석: 진단에서 시스템까지에 대한 직접 링크" translate="no">​</a></h2>
<p>초록의 서사는 표현력 격차를 synthetic task로 진단하고 → 그 원인을 회상·비교로 좁힌 뒤 → H3 계층을 제안하고 → FlashConv로 실행 병목을 다루며 → 하이브리드 모델과 대규모 학습으로 검증하는 구조입니다. 즉 알고리즘과 시스템 최적화를 따로 설명하지 않고, “언어에 필요한 능력”과 “그 능력을 하드웨어에서 실행하는 비용”을 연속된 문제로 다룹니다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="실무적-함의와-한계">실무적 함의와 한계<a href="https://ql.gl/ko/blog/7ecdd9d9/#%EC%8B%A4%EB%AC%B4%EC%A0%81-%ED%95%A8%EC%9D%98%EC%99%80-%ED%95%9C%EA%B3%84" class="hash-link" aria-label="실무적 함의와 한계에 대한 직접 링크" title="실무적 함의와 한계에 대한 직접 링크" translate="no">​</a></h2>
<p>SSM 기반 언어 모델을 평가할 때 평균 perplexity만 보아서는 부족합니다. 특정 과거 토큰을 찾아야 하는 회상 테스트, 두 위치의 일치·불일치를 판별하는 비교 테스트, 긴 문맥에서의 최악 사례를 별도로 구성해야 합니다. 또한 커널 최적화는 모델 품질과 독립적인 운영 변수이므로 실제 추론 처리량과 메모리 사용량을 측정해야 합니다.</p>
<p>제공된 자료에서 확인되지 않는 항목도 분명합니다. H3의 세부 수식과 ablation, FlashConv의 정확한 커널·하드웨어 설정, 각 속도 비교의 배치와 정밀도, 2.7B 학습의 전체 절차, 현재 모델과의 비교입니다. 따라서 이 논문은 SSM을 곧바로 Transformer의 대체재로 확정하는 근거가 아니라, 언어 모델링의 실패 모드를 분해하고 하이브리드 설계 가능성을 보여주는 연구로 읽는 편이 정확합니다.</p>
<p>운영 관점에서 하이브리드 구조는 새로운 배포 단위도 만듭니다. attention 층은 특정 토큰 간 비교를 위해 메모리와 연산을 사용하고, H3·FlashConv 경로는 긴 흐름을 처리합니다. 어느 경로가 병목인지 입력 길이와 배치에 따라 달라질 수 있으므로, 모델 전체 평균이 아니라 층별 프로파일을 수집해야 합니다. 초록의 속도 수치를 그대로 서비스 목표로 삼기보다, 동일한 토크나이저와 출력 길이에서 end-to-end 지연을 다시 측정해야 하는 이유입니다.</p>
<p>평가 데이터의 성격도 중요합니다. synthetic task에서 회상과 비교가 개선되었다고 해도, 실제 웹 텍스트의 장거리 담화와 지식 검색이 같은 방식으로 개선된다고 자동으로 결론 내릴 수는 없습니다. 반대로 OpenWebText의 PPL 근접성이 모든 downstream 작업을 보장하는 것도 아닙니다. 논문이 제시한 synthetic·언어 모델링·SuperGLUE 결과를 서로 다른 증거 층으로 읽고, 적용 도메인별 검증을 이어가야 합니다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="sources">Sources<a href="https://ql.gl/ko/blog/7ecdd9d9/#sources" class="hash-link" aria-label="Sources에 대한 직접 링크" title="Sources에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class=""><a href="https://arxiv.org/abs/2212.14052" target="_blank" rel="noopener noreferrer" class="">Hungry Hungry Hippos: Towards Language Modeling with State Space Models</a> — license: <code>unknown</code>, retrieved: <code>2026-08-19</code>, source type: <code>original</code>.</li>
<li class="">Image: <a href="https://arxiv.org/abs/2212.14052" target="_blank" rel="noopener noreferrer" class="">Placeholder — 원문 기반 커버 이미지 미제작</a> — license: <code>unknown-placeholder</code>.</li>
</ul>]]></content>
        <author>
            <name>p4r4d0xb0x</name>
            <uri>https://bdev.io</uri>
        </author>
        <category label="AI" term="AI"/>
        <category label="Research" term="Research"/>
        <category label="Language Modeling" term="Language Modeling"/>
        <category label="SSM" term="SSM"/>
        <category label="Attention" term="Attention"/>
        <category label="Explainer" term="Explainer"/>
    </entry>
    <entry>
        <title type="html"><![CDATA[Mamba: 선택적 상태공간으로 콘텐츠 기반 추론에 접근하기]]></title>
        <id>https://ql.gl/ko/blog/1d139737/</id>
        <link href="https://ql.gl/ko/blog/1d139737/"/>
        <updated>2026-08-19T00:00:00.000Z</updated>
        <summary type="html"><![CDATA[Mamba가 입력에 따라 상태공간 파라미터를 바꾸는 selective SSM과 하드웨어 인식 병렬 알고리즘으로 긴 시퀀스의 효율성과 언어 모델링 성능을 함께 겨냥한 이유를 설명합니다.]]></summary>
        <content type="html"><![CDATA[<p>상태공간모델(SSM)은 긴 시퀀스를 선형 시간에 처리할 가능성이 있지만, 언어처럼 토큰의 의미에 따라 무엇을 기억할지 결정해야 하는 작업에서는 약점이 드러났습니다. <strong>Mamba: Linear-Time Sequence Modeling with Selective State Spaces</strong>는 이 문제를 “상태가 고정된 채 모든 입력을 같은 규칙으로 처리한다”는 관점에서 다시 봅니다. 제안은 간단한 문장으로 요약할 수 있습니다. 입력에 따라 SSM 파라미터를 바꾸어, 현재 토큰에 따라 정보를 선택적으로 전달하거나 잊게 하자는 것입니다.</p>
<p><img decoding="async" loading="lazy" src="https://ql.gl/img/blog/mamba-selective-state-spaces/cover.webp" alt="입력 토큰에 따라 정보를 선택적으로 전달하고 잊는 Mamba 상태공간 흐름" class="img_ev3q"></p>
<p>이 초안은 arXiv 공개 초록과 메타데이터에서 확인되는 주장만 사용합니다. 모델 내부의 세부 블록 구성, 정확한 커널 구현, 각 실험의 조건은 원문 본문과 코드로 추가 검증해야 합니다.</p>
<!-- -->
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="고정된-압축의-문제">고정된 압축의 문제<a href="https://ql.gl/ko/blog/1d139737/#%EA%B3%A0%EC%A0%95%EB%90%9C-%EC%95%95%EC%B6%95%EC%9D%98-%EB%AC%B8%EC%A0%9C" class="hash-link" aria-label="고정된 압축의 문제에 대한 직접 링크" title="고정된 압축의 문제에 대한 직접 링크" translate="no">​</a></h2>
<p>Transformer의 attention은 현재 토큰이 어떤 과거 토큰을 참조할지 입력 내용에 따라 계산합니다. 반면 기존 SSM 계열은 긴 입력을 고정된 상태 업데이트 규칙으로 압축하기 때문에, 이산적인 언어에서 콘텐츠 기반 추론을 수행하기 어렵다고 논문은 진단합니다. 여기서 핵심은 단순한 길이 문제가 아닙니다. 백만 토큰을 처리하는 능력보다, 그중 어떤 정보가 현재 판단에 중요해졌는지를 구별하는 능력이 먼저 필요합니다.</p>
<p>Mamba는 입력의 함수로 SSM 파라미터를 만들면 이 약점을 완화할 수 있다고 제안합니다. 현재 토큰에 따라 시퀀스 길이 방향으로 정보를 선택적으로 전파하거나 망각하는 것입니다. 이 설계는 SSM의 압축 장점을 유지하면서도, 모든 토큰을 동일한 중요도로 다루지 않으려는 방향입니다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 선택적 SSM(selective SSM)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 입력 내용에 따라 어떤 정보를 상태에 남기고 어떤 정보를 흘려보낼지 바꾸는 상태공간모델입니다.</p><p>예시: 회의록을 모두 같은 크기로 요약하지 않고, 결정사항은 굵게 남기고 인사말은 짧게 줄이는 자동 기록 방식과 같습니다.</p></div></div>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="mamba의-계산-경로">Mamba의 계산 경로<a href="https://ql.gl/ko/blog/1d139737/#mamba%EC%9D%98-%EA%B3%84%EC%82%B0-%EA%B2%BD%EB%A1%9C" class="hash-link" aria-label="Mamba의 계산 경로에 대한 직접 링크" title="Mamba의 계산 경로에 대한 직접 링크" translate="no">​</a></h2>
<p>입력 의존적 파라미터는 표현력에는 도움이 되지만, 기존 SSM에서 쓰던 효율적인 convolution을 그대로 사용할 수 없게 만듭니다. 논문은 이 상충을 해결하기 위해 recurrent mode에서 실행되는 hardware-aware parallel algorithm을 설계했다고 설명합니다. 즉 계산을 단순히 이론적 선형성으로 끝내지 않고, GPU 같은 실제 장치가 병렬 실행할 수 있는 형태로 재구성하려는 접근입니다.</p>
<p>Mamba는 selective SSM을 단순화한 end-to-end 신경망 구조에 통합합니다. 초록은 attention뿐 아니라 MLP block도 사용하지 않는다고 명시합니다. 이 구성은 “attention을 조금 줄인 Transformer”라기보다, 상태 업데이트를 중심 계산 단위로 삼는 다른 백본을 만들려는 시도입니다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 하드웨어 인식 알고리즘(hardware-aware algorithm)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 수학적 연산 횟수만 보지 않고 메모리 이동, 병렬성, 캐시와 커널 실행 방식까지 고려해 만든 알고리즘입니다.</p><p>예시: 같은 양의 물건을 옮기더라도 한 개씩 여러 번 나르는 대신, 창고 통로와 카트 크기에 맞춰 한 번에 옮기는 작업 계획입니다.</p></div></div>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: recurrent mode</div><div class="admonitionContent_BuS1"><p>쉬운정의: 입력을 한 단계씩 읽으며 이전 상태를 다음 상태로 넘기는 실행 방식입니다.</p><p>예시: 긴 책을 읽을 때 앞 장의 메모를 다음 장으로 넘겨가며 읽는 방식입니다. 전체 책을 매번 다시 펼치지 않는 대신, 메모의 품질이 중요해집니다.</p></div></div>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="논문이-보고한-성능과-해석의-경계">논문이 보고한 성능과 해석의 경계<a href="https://ql.gl/ko/blog/1d139737/#%EB%85%BC%EB%AC%B8%EC%9D%B4-%EB%B3%B4%EA%B3%A0%ED%95%9C-%EC%84%B1%EB%8A%A5%EA%B3%BC-%ED%95%B4%EC%84%9D%EC%9D%98-%EA%B2%BD%EA%B3%84" class="hash-link" aria-label="논문이 보고한 성능과 해석의 경계에 대한 직접 링크" title="논문이 보고한 성능과 해석의 경계에 대한 직접 링크" translate="no">​</a></h2>
<p>초록은 Mamba가 Transformer보다 5배 높은 inference throughput을 보이고, 시퀀스 길이에 선형으로 확장된다고 보고합니다. 또한 백만 길이까지 실제 데이터에서 성능이 향상된다고 설명합니다. 여러 모달리티의 범용 시퀀스 백본으로서 언어·오디오·유전체학에서 당시 최고 성능을 달성했다고 주장하며, 언어 모델링에서는 Mamba-3B가 같은 크기의 Transformer를 앞서고 두 배 크기 Transformer와 맞먹는다고 보고합니다.</p>
<p>이 수치들은 강한 연구 결과지만 조건 없는 속도 법칙은 아닙니다. throughput은 배치, 정밀도, 하드웨어, 시퀀스 길이, 구현 커널에 영향을 받습니다. “두 배 크기와 동등” 역시 논문이 정의한 사전학습·다운스트림 평가의 범위에서 읽어야 합니다. 초록만으로는 데이터 구성, 기준선의 세부, 통계적 변동, 긴 시퀀스의 구체적 실패 사례를 확인할 수 없습니다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="s4에서-mamba로-이어지는-설계-질문">S4에서 Mamba로 이어지는 설계 질문<a href="https://ql.gl/ko/blog/1d139737/#s4%EC%97%90%EC%84%9C-mamba%EB%A1%9C-%EC%9D%B4%EC%96%B4%EC%A7%80%EB%8A%94-%EC%84%A4%EA%B3%84-%EC%A7%88%EB%AC%B8" class="hash-link" aria-label="S4에서 Mamba로 이어지는 설계 질문에 대한 직접 링크" title="S4에서 Mamba로 이어지는 설계 질문에 대한 직접 링크" translate="no">​</a></h2>
<p>이 연구의 위치는 SSM을 단순히 attention보다 값싼 계산으로 보는 시선을 바꿉니다. S4가 구조화된 상태 행렬과 커널 계산으로 긴 의존성을 효율화했다면, Mamba는 정보 선택을 상태 업데이트에 넣어 콘텐츠 기반 추론의 약점을 겨냥합니다. 하지만 선택성을 도입하는 순간 convolution 기반 병렬화의 이점을 잃을 수 있으므로, Mamba의 알고리즘 기여는 그 손실을 hardware-aware recurrent 계산으로 보상하려는 데 있습니다.</p>
<p>따라서 비교의 축은 “quadratic 대 linear” 하나가 아닙니다.</p>
<ul>
<li class=""><strong>정보 경로</strong>: 과거 토큰을 명시적으로 비교하는가, 압축 상태로 전달하는가</li>
<li class=""><strong>선택성</strong>: 입력 내용이 기억·망각 규칙을 바꾸는가</li>
<li class=""><strong>실행 경로</strong>: 이론적 복잡도와 실제 메모리 이동이 어떻게 다른가</li>
<li class=""><strong>확장성</strong>: 긴 문맥에서 품질과 처리량이 함께 유지되는가</li>
</ul>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="실무적-함의">실무적 함의<a href="https://ql.gl/ko/blog/1d139737/#%EC%8B%A4%EB%AC%B4%EC%A0%81-%ED%95%A8%EC%9D%98" class="hash-link" aria-label="실무적 함의에 대한 직접 링크" title="실무적 함의에 대한 직접 링크" translate="no">​</a></h2>
<p>Mamba류 백본을 검토하는 팀은 먼저 업무의 정보 접근 패턴을 분류해야 합니다. 긴 로그나 오디오처럼 흐름을 압축하며 읽는 작업에는 상태 기반 모델이 자연스러울 수 있습니다. 반면 특정 문서의 특정 구절을 정확히 찾아 여러 위치와 대조해야 하는 작업에서는 선택적 상태가 실제로 그 정보를 보존하는지 별도 검증이 필요합니다.</p>
<p>평가에서는 평균 점수와 함께 길이별 처리량, 첫 토큰 지연, 지속 상태의 메모리 크기, 긴 문맥에서의 회상·비교 테스트를 측정해야 합니다. 운영 환경에서는 recurrent state가 요청 간 섞이지 않도록 세션 경계를 관리하고, 스트리밍 실패 시 상태를 어떻게 폐기하거나 재생성할지도 정해야 합니다. 이런 운영 세부는 초록이 다루지 않으므로 Mamba의 논문 결과에서 자동으로 보장된다고 말할 수 없습니다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="한계와-미해결-질문">한계와 미해결 질문<a href="https://ql.gl/ko/blog/1d139737/#%ED%95%9C%EA%B3%84%EC%99%80-%EB%AF%B8%ED%95%B4%EA%B2%B0-%EC%A7%88%EB%AC%B8" class="hash-link" aria-label="한계와 미해결 질문에 대한 직접 링크" title="한계와 미해결 질문에 대한 직접 링크" translate="no">​</a></h2>
<p>제공된 자료에서 확인되지 않는 핵심은 selective SSM 파라미터의 정확한 수식과 안정성, 하드웨어 인식 병렬 알고리즘의 구현 조건, 5배 throughput의 비교 환경, 백만 길이 실험의 데이터·메모리 설정, 모달리티별 기준선과 실패 사례입니다. 또한 “콘텐츠 기반 추론을 해결한다”는 표현은 실제로 모든 attention형 검색·비교 문제를 해결한다는 뜻이 아니라, 논문이 식별한 약점을 입력 의존적 상태 업데이트로 완화하려는 주장으로 읽어야 합니다.</p>
<p>실제 채택 전에는 원문 방법·실험 절과 공개 구현을 확인하고, 사용하려는 하드웨어에서 동일한 길이·배치·정밀도로 재측정해야 합니다. Mamba의 의의는 Transformer를 선언적으로 폐기한 데 있지 않고, 기억의 선택성과 하드웨어 실행을 하나의 상태공간 설계 문제로 결합한 데 있습니다.</p>
<p>이 관점은 모델을 선택하는 방식에도 영향을 줍니다. 짧은 입력에서는 attention의 절대 비용이 작아 Mamba의 선형 확장성이 실질적 이점으로 나타나지 않을 수 있습니다. 반대로 긴 스트림에서는 상태가 작고 일정하다는 장점이 커질 수 있지만, 상태가 너무 공격적으로 정보를 버리면 중요한 단서가 복구되지 않습니다. 따라서 문맥 길이별 품질 곡선과 정보 보존 실패를 함께 기록해야 합니다.</p>
<p>또한 선택성은 디버깅을 어렵게 만들 수 있습니다. attention에서는 특정 출력이 어떤 키와 값에 의존했는지 분석할 단서가 비교적 명시적이지만, 선택적 상태에서는 정보가 여러 단계의 업데이트를 거쳐 압축됩니다. 이 차이는 해석 가능성의 우열을 단정하는 근거는 아니지만, 장애 분석과 안전성 평가에서 관찰 도구가 추가로 필요하다는 실무적 신호입니다. 이 문제는 arXiv 초록이 보고한 성능과는 별개의 도입 과제입니다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="sources">Sources<a href="https://ql.gl/ko/blog/1d139737/#sources" class="hash-link" aria-label="Sources에 대한 직접 링크" title="Sources에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class=""><a href="https://arxiv.org/abs/2312.00752" target="_blank" rel="noopener noreferrer" class="">Mamba: Linear-Time Sequence Modeling with Selective State Spaces</a> — license: <code>unknown</code>, retrieved: <code>2026-08-19</code>, source type: <code>original</code>.</li>
<li class="">Image: <a href="https://arxiv.org/abs/2312.00752" target="_blank" rel="noopener noreferrer" class="">Placeholder — 원문 기반 커버 이미지 미제작</a> — license: <code>unknown-placeholder</code>.</li>
</ul>]]></content>
        <author>
            <name>p4r4d0xb0x</name>
            <uri>https://bdev.io</uri>
        </author>
        <category label="AI" term="AI"/>
        <category label="Research" term="Research"/>
        <category label="Mamba" term="Mamba"/>
        <category label="SSM" term="SSM"/>
        <category label="Language Modeling" term="Language Modeling"/>
        <category label="Explainer" term="Explainer"/>
    </entry>
    <entry>
        <title type="html"><![CDATA[Mamba-2는 왜 Transformer와 닮았는가: SSD로 다시 읽는 SSM]]></title>
        <id>https://ql.gl/ko/blog/76b0dce0/</id>
        <link href="https://ql.gl/ko/blog/76b0dce0/"/>
        <updated>2026-08-19T00:00:00.000Z</updated>
        <summary type="html"><![CDATA[Tri Dao와 Albert Gu의 Mamba-2 논문을 따라가며 상태공간모델과 어텐션의 연결, SSD 알고리즘의 하드웨어적 의미, 그리고 확인되지 않은 주장까지 정리한다.]]></summary>
        <content type="html"><![CDATA[<p><img decoding="async" loading="lazy" src="https://ql.gl/img/blog/mamba2-ssd/cover.webp" alt="상태공간모델과 어텐션을 구조화된 행렬로 연결하는 개념도" class="img_ev3q"></p>
<p>긴 문장을 다루는 모델의 병목은 단순히 파라미터 수가 아니다. 학습에서는 긴 시퀀스의 모든 위치를 병렬로 처리해야 하고, 생성에서는 매 토큰마다 과거 정보를 읽어야 한다. Transformer는 강력한 전역 어텐션을 얻는 대신 시퀀스 길이에 따른 계산과 메모리 부담을 감수한다. Mamba 계열의 상태공간모델(SSM)은 recurrent state를 유지해 생성 시 상태 크기를 고정하려 하지만, 학습과 GPU 활용을 Transformer만큼 쉽게 설명하기 어렵다.</p>
<p>Tri Dao와 Albert Gu의 논문은 이 둘을 경쟁하는 상자처럼 놓지 않는다. 핵심 질문은 “SSM과 어텐션을 같은 구조적 언어로 표현할 수 있는가”다. 논문은 구조적 준반분리 행렬(structured semiseparable matrix)을 매개로 두 계열의 관계를 정리하고, 그 관점에서 Mamba-2의 핵심 계층과 SSD 알고리즘을 제안한다. 아래 내용은 arXiv 원문과 HTML의 초록·방법·실험 서술에 근거하며, 재현 코드 실행 결과를 추가한 글이 아니다.</p>
<!-- -->
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="문제-선형-복잡도만으로는-충분하지-않다">문제: 선형 복잡도만으로는 충분하지 않다<a href="https://ql.gl/ko/blog/76b0dce0/#%EB%AC%B8%EC%A0%9C-%EC%84%A0%ED%98%95-%EB%B3%B5%EC%9E%A1%EB%8F%84%EB%A7%8C%EC%9C%BC%EB%A1%9C%EB%8A%94-%EC%B6%A9%EB%B6%84%ED%95%98%EC%A7%80-%EC%95%8A%EB%8B%A4" class="hash-link" aria-label="문제: 선형 복잡도만으로는 충분하지 않다에 대한 직접 링크" title="문제: 선형 복잡도만으로는 충분하지 않다에 대한 직접 링크" translate="no">​</a></h2>
<p>SSM의 전형적인 형태는 상태를 갱신하는 식으로 쓸 수 있다.</p>
<div class="language-text codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#f8f8f2;--prism-background-color:#272822"><div class="codeBlockContent_QJqH"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar" style="color:#f8f8f2;background-color:#272822"><code class="codeBlockLines_e6Vv"><div class="token-line" style="color:#f8f8f2"><span class="token plain">h_t = A_t h_{t-1} + B_t x_t</span><br></div><div class="token-line" style="color:#f8f8f2"><span class="token plain"> y_t = C_t^T h_t</span><br></div></code></pre></div></div>
<p>상태 <code>h</code>는 과거 입력을 압축한 작업 메모리다. 생성 시에는 전체 토큰을 다시 보지 않고 이 상태만 다음 단계로 넘길 수 있다. Mamba의 선택적(selective) SSM처럼 <code>A</code>, <code>B</code>, <code>C</code>가 입력에 따라 달라지면 어떤 정보가 유지되고 지워질지도 토큰별로 조절된다. 그러나 한 토큰씩 순서대로 갱신하는 계산은 GPU의 행렬곱 장치를 충분히 활용하지 못할 수 있다. 따라서 “시퀀스 길이에 선형”이라는 점과 “실제 하드웨어에서 빠르다”는 주장은 분리해 봐야 한다.</p>
<p>논문이 제시하는 관점은 같은 변환을 세 가지 방식으로 볼 수 있다는 것이다. recurrent form은 순차 상태 갱신을 보여 주고, quadratic form은 모든 위치 사이의 상호작용을 행렬로 드러내며, matrix form은 둘 사이를 구조적으로 연결한다. 이 연결은 SSM을 단지 새로운 RNN으로 보는 대신, 이미 최적화가 풍부한 어텐션 계산과 같은 문제 공간에 놓는다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 상태공간모델(SSM)</div><div class="admonitionContent_BuS1"><p>쉬운 정의: 입력을 받을 때마다 내부 상태를 갱신하고, 그 상태에서 출력을 만드는 시퀀스 모델이다.</p><p>예시: 메모장에 지금까지의 대화를 한 줄 요약해 두고 다음 문장을 읽을 때 그 요약만 참고하는 방식이다. 요약 규칙과 보관량을 학습할 수 있다는 점이 일반적인 메모와 다르다.</p></div></div>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="ssd의-핵심-행렬-구조가-두-계산-경로를-잇는다">SSD의 핵심: 행렬 구조가 두 계산 경로를 잇는다<a href="https://ql.gl/ko/blog/76b0dce0/#ssd%EC%9D%98-%ED%95%B5%EC%8B%AC-%ED%96%89%EB%A0%AC-%EA%B5%AC%EC%A1%B0%EA%B0%80-%EB%91%90-%EA%B3%84%EC%82%B0-%EA%B2%BD%EB%A1%9C%EB%A5%BC-%EC%9E%87%EB%8A%94%EB%8B%A4" class="hash-link" aria-label="SSD의 핵심: 행렬 구조가 두 계산 경로를 잇는다에 대한 직접 링크" title="SSD의 핵심: 행렬 구조가 두 계산 경로를 잇는다에 대한 직접 링크" translate="no">​</a></h2>
<p>논문은 SSM이 특정한 준반분리 행렬로 표현될 수 있음을 보인다. 이 행렬은 모든 위치의 관계를 무작정 저장하지 않는다. 대각선 블록과 낮은 랭크(low-rank) 블록 같은 구조를 이용해 필요한 매개변수와 곱셈을 줄인다. 그 결과 같은 연산을 순차 recurrence로 계산할 수도 있고, 블록 단위 행렬곱으로 계산할 수도 있다.</p>
<p>SSD(State Space Duality)는 이 이중성을 이름 붙인 프레임워크다. 중요한 것은 “어텐션이 SSM과 완전히 동일하다”는 식의 단순화가 아니다. 논문은 모든 어텐션이 아니라, 구조적 행렬로 표현되는 특정한 SSM과 커널·마스킹 변형 사이의 관계를 다룬다고 명시한다. 즉 제목의 직관은 강력하지만 적용 범위는 수학적 조건 안에 있다.</p>
<p>실행 알고리즘은 시퀀스를 청크로 나누어 블록 내부에서는 병렬 행렬 연산을 사용하고, 블록 사이에서는 요약된 recurrent state를 전달하는 방식으로 설명된다. 이 방식은 순차 계산의 상태 의미를 유지하면서도 GPU가 잘하는 큰 행렬곱을 끌어온다. 논문이 말하는 하드웨어 효율성은 바로 이 계산 경로의 선택 가능성에서 나온다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 준반분리 행렬(semiseparable matrix)</div><div class="admonitionContent_BuS1"><p>쉬운 정의: 전체 행렬처럼 보이지만, 위치 사이의 많은 블록이 낮은 랭크의 작은 표현으로 압축되는 구조적 행렬이다.</p><p>예시: 도시 전체 도로 지도를 모든 교차로 쌍으로 저장하는 대신, 구역별 요약과 구역 사이 연결 규칙으로 보관하는 것과 비슷하다. 필요한 경로 계산은 가능하지만 저장과 계산량은 줄어든다.</p></div></div>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: recurrent state</div><div class="admonitionContent_BuS1"><p>쉬운 정의: 다음 입력을 처리할 때 과거 전체 대신 전달되는 고정 크기의 내부 값이다.</p><p>예시: 긴 회의의 모든 녹취 대신 회의록 한 장을 다음 회의에 가져가는 것이다. 회의록이 작을수록 편하지만, 중요한 세부를 잃을 가능성도 함께 관리해야 한다.</p></div></div>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="mamba-2에서-바뀐-것은-알고리즘만이-아니다">Mamba-2에서 바뀐 것은 알고리즘만이 아니다<a href="https://ql.gl/ko/blog/76b0dce0/#mamba-2%EC%97%90%EC%84%9C-%EB%B0%94%EB%80%90-%EA%B2%83%EC%9D%80-%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98%EB%A7%8C%EC%9D%B4-%EC%95%84%EB%8B%88%EB%8B%A4" class="hash-link" aria-label="Mamba-2에서 바뀐 것은 알고리즘만이 아니다에 대한 직접 링크" title="Mamba-2에서 바뀐 것은 알고리즘만이 아니다에 대한 직접 링크" translate="no">​</a></h2>
<p>논문은 SSD 계층과 함께 Mamba 블록의 설계도 조정한다. 데이터 의존적 projection을 블록 시작 부분에서 병렬로 계산하고, 어텐션의 multi-head에서 빌려온 head 구조를 SSM의 선택지로 가져온다. 또한 tensor parallelism을 적용하기 쉽도록 동기화 지점을 줄이는 설계를 설명한다. 긴 시퀀스를 여러 장치에 나누는 sequence parallelism에서는 장치 사이에 recurrent state를 넘기는 방식도 제시한다.</p>
<p>이 부분의 실무적 의미는 새 계층 하나의 FLOPs만 보는 것이 아니라 학습 시스템 전체를 바꿔야 한다는 데 있다. 커널, 통신, 가변 길이 배치, 메모리 레이아웃이 함께 맞아야 실제 지연 시간이 줄어든다. 논문은 variable-length sequence에서 패딩을 피하는 방법도 논의하지만, 각 하드웨어·프레임워크 조합에서 동일한 효과가 재현된다고 보장하지는 않는다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="논문-구조와-근거의-범위">논문 구조와 근거의 범위<a href="https://ql.gl/ko/blog/76b0dce0/#%EB%85%BC%EB%AC%B8-%EA%B5%AC%EC%A1%B0%EC%99%80-%EA%B7%BC%EA%B1%B0%EC%9D%98-%EB%B2%94%EC%9C%84" class="hash-link" aria-label="논문 구조와 근거의 범위에 대한 직접 링크" title="논문 구조와 근거의 범위에 대한 직접 링크" translate="no">​</a></h2>
<p>원문은 Introduction에서 Transformer와 SSM의 문제를 제시한 뒤, Background에서 SSM·어텐션·구조적 행렬을 정리한다. 이어 SSM을 행렬로 표현하고, structured masked attention과 SSD의 이론적 관계를 전개한 다음, 효율 알고리즘·Mamba-2 설계·시스템 최적화·실험으로 이동한다. 이는 문제→공통 표현→알고리즘→아키텍처→검증의 흐름이다.</p>
<p>초록과 본문은 SSD 핵심 계층이 Mamba의 선택적 scan보다 2–8배 빠르며 Transformer와 경쟁적인 언어모델링 성능을 보였다고 보고한다. 본문에는 특정 조건에서 FlashAttention-2와의 교차점과 긴 시퀀스 속도 비교, Pile 학습과 downstream 평가, scaling law 및 ablation이 포함된다. 그러나 이 수치는 원문이 설정한 구현·하드웨어·배치·길이 조건의 결과다. 이 글에서는 별도의 벤치마크를 수행하지 않았으므로 “모든 환경에서 2–8배”로 일반화하지 않는다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="실무적으로-무엇이-달라지는가">실무적으로 무엇이 달라지는가<a href="https://ql.gl/ko/blog/76b0dce0/#%EC%8B%A4%EB%AC%B4%EC%A0%81%EC%9C%BC%EB%A1%9C-%EB%AC%B4%EC%97%87%EC%9D%B4-%EB%8B%AC%EB%9D%BC%EC%A7%80%EB%8A%94%EA%B0%80" class="hash-link" aria-label="실무적으로 무엇이 달라지는가에 대한 직접 링크" title="실무적으로 무엇이 달라지는가에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class=""><strong>추론 서버:</strong> 전체 KV cache 대신 고정 크기 상태를 유지하는 설계는 긴 입력이나 동시 사용자 수가 많은 서비스에서 메모리 계획을 단순화할 가능성이 있다. 다만 상태가 긴 문맥의 모든 정보를 보존한다는 뜻은 아니다.</li>
<li class=""><strong>학습 스택:</strong> SSD의 chunkwise·block 구조는 GEMM과 tensor parallelism을 활용할 여지를 준다. 실제 도입 전에는 커널 구현과 통신 비용을 함께 프로파일링해야 한다.</li>
<li class=""><strong>모델 선택:</strong> Mamba-2는 Transformer의 대체품이라는 한 문장보다, recurrent inference와 병렬 학습 사이의 절충점을 제공하는 계층으로 보는 편이 정확하다.</li>
<li class=""><strong>평가:</strong> perplexity와 downstream 점수 외에 긴 문맥 회수, 상태 크기, batch 크기별 지연·처리량, 메모리 피크를 같은 조건에서 측정해야 한다.</li>
</ul>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="한계와-남은-질문">한계와 남은 질문<a href="https://ql.gl/ko/blog/76b0dce0/#%ED%95%9C%EA%B3%84%EC%99%80-%EB%82%A8%EC%9D%80-%EC%A7%88%EB%AC%B8" class="hash-link" aria-label="한계와 남은 질문에 대한 직접 링크" title="한계와 남은 질문에 대한 직접 링크" translate="no">​</a></h2>
<p>논문은 SSM과 어텐션의 깊은 연결을 제시하지만, 그 연결이 모든 softmax attention의 동등한 대체를 의미하지는 않는다. 또한 reported speedup은 특정 최적화 구현의 결과이므로 새 GPU, 다른 정밀도, 작은 batch, 실제 serving workload에서 다시 확인해야 한다. recurrent state가 문맥을 압축하는 만큼, 복잡한 임의 회수나 장거리 상호작용에서 어떤 정보 손실 패턴을 보이는지도 애플리케이션별 검증이 필요하다.</p>
<p>제공된 자료에서 확인되는 범위에서 Mamba-2의 가장 중요한 기여는 “선형 복잡도”라는 표어가 아니다. 동일한 시퀀스 변환을 recurrence와 행렬곱 양쪽으로 바라보고, 그 선택을 하드웨어와 분산 학습의 언어로 연결한 점이다. 정량적 성능은 추가 검증이 필요하지만, 연구 방향은 분명하다. 새로운 아키텍처의 승부처는 수식의 우아함과 커널·메모리·통신의 현실을 함께 설명할 수 있는가에 있다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="sources">Sources<a href="https://ql.gl/ko/blog/76b0dce0/#sources" class="hash-link" aria-label="Sources에 대한 직접 링크" title="Sources에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class="">Tri Dao, Albert Gu, “Transformers are SSMs: Generalized Models and Efficient Algorithms Through Structured State Space Duality,” arXiv:2405.21060, submitted 2024-05-31, CC BY 4.0. <a href="https://arxiv.org/abs/2405.21060" target="_blank" rel="noopener noreferrer" class="">https://arxiv.org/abs/2405.21060</a></li>
<li class="">HTML full text, arXiv:2405.21060v1, sections 1–9, retrieved 2026-08-19. <a href="https://arxiv.org/html/2405.21060v1" target="_blank" rel="noopener noreferrer" class="">https://arxiv.org/html/2405.21060v1</a></li>
</ul>]]></content>
        <author>
            <name>p4r4d0xb0x</name>
            <uri>https://bdev.io</uri>
        </author>
        <category label="AI" term="AI"/>
        <category label="Research" term="Research"/>
        <category label="SSM" term="SSM"/>
        <category label="Mamba" term="Mamba"/>
        <category label="Transformer" term="Transformer"/>
    </entry>
    <entry>
        <title type="html"><![CDATA[Griffin의 절충안: Gated Linear Recurrence와 Local Attention을 함께 쓰는 법]]></title>
        <id>https://ql.gl/ko/blog/dd8d73cd/</id>
        <link href="https://ql.gl/ko/blog/dd8d73cd/"/>
        <updated>2026-08-19T00:00:00.000Z</updated>
        <summary type="html"><![CDATA[Hawk와 Griffin이 순환 모델의 효율성과 Transformer의 표현력을 어떻게 조합하는지, 논문이 보고한 근거와 실제 도입 시 남는 질문을 분리해 읽는다.]]></summary>
        <content type="html"><![CDATA[<p><img decoding="async" loading="lazy" src="https://ql.gl/img/blog/griffin-gated-linear-recurrence/cover.webp" alt="선형 recurrence와 지역 어텐션이 교차하는 시퀀스 모델 구조" class="img_ev3q"></p>
<p>Transformer는 모든 위치를 직접 비교하는 능력으로 언어 모델링의 표준이 됐지만, 생성 시 과거의 키와 값을 계속 보관해야 한다. 반대로 전통적인 순환신경망(RNN)은 토큰마다 상태 하나를 갱신하므로 추론 비용이 작지만, 시간축 병렬화와 대규모 학습이 어렵다. Griffin 논문은 이 대립을 “둘 중 하나를 고르는 문제”로 다루지 않는다. Hawk라는 gated linear recurrence와, Hawk에 local attention을 섞은 Griffin을 함께 제안해 서로 다른 시간 범위의 기억을 분담시킨다.</p>
<p>논문의 초록은 Hawk가 보고된 Mamba 성능을 넘고, Griffin이 Llama-2와 경쟁적인 성능을 6배 이상 적은 학습 토큰으로 달성했다고 보고한다. 또한 학습 중 Transformer와 비슷한 하드웨어 효율, 추론 중 낮은 지연과 높은 처리량, 학습 길이보다 긴 시퀀스에 대한 extrapolation을 주장한다. 다만 이 글은 초록과 원문 실험 조건을 근거로 쓰며, 외부 재현 결과나 새로운 비교를 추가하지 않는다.</p>
<!-- -->
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="hawk-rnn의-상태를-게이트로-다시-설계하기">Hawk: RNN의 상태를 게이트로 다시 설계하기<a href="https://ql.gl/ko/blog/dd8d73cd/#hawk-rnn%EC%9D%98-%EC%83%81%ED%83%9C%EB%A5%BC-%EA%B2%8C%EC%9D%B4%ED%8A%B8%EB%A1%9C-%EB%8B%A4%EC%8B%9C-%EC%84%A4%EA%B3%84%ED%95%98%EA%B8%B0" class="hash-link" aria-label="Hawk: RNN의 상태를 게이트로 다시 설계하기에 대한 직접 링크" title="Hawk: RNN의 상태를 게이트로 다시 설계하기에 대한 직접 링크" translate="no">​</a></h2>
<p>선형 recurrence는 현재 입력과 이전 상태의 선형 결합으로 이해할 수 있다. 간단히 쓰면 <code>h_t = a_t ⊙ h_{t-1} + b_t ⊙ x_t</code>와 같은 형태다. 여기서 게이트는 과거를 얼마나 지우고 새 입력을 얼마나 쓸지 조절한다. Griffin 논문의 Hawk는 이 아이디어를 언어 모델 블록 안에 넣되, 입력 의존적 게이트와 안정적인 정규화를 사용해 학습 가능성을 높인다.</p>
<p>이 설계의 양면성은 분명하다. 생성 시에는 현재 토큰과 고정 크기 상태만 읽고 쓰므로 시퀀스 전체를 다시 순회할 필요가 없다. 반면 시간축 recurrence는 본질적으로 순서 의존적이어서 학습 병렬화가 어려워질 수 있다. 논문은 gated linear recurrence를 parallel scan으로 계산할 수 있는 형태로 정리하고, 실제 모델이 Transformer와 비슷한 학습 하드웨어 효율을 보이도록 구현·구조를 함께 설계한다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 게이티드 선형 recurrence</div><div class="admonitionContent_BuS1"><p>쉬운 정의: 과거 상태와 새 입력을 더할 때, 학습된 게이트가 각각의 비중을 조절하는 순환 계산이다.</p><p>예시: 냉장고에 남은 음식을 기록할 때 오래된 메모를 전부 버리거나 전부 보존하지 않고, 유통기한이 지난 항목은 지우고 새로 산 항목은 크게 반영하는 방식이다.</p></div></div>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: parallel scan</div><div class="admonitionContent_BuS1"><p>쉬운 정의: 순서가 있는 누적 계산을 여러 묶음으로 나누어 병렬 처리한 뒤, 묶음 사이의 요약 상태를 연결하는 알고리즘이다.</p><p>예시: 긴 줄의 합계를 한 사람이 처음부터 더하는 대신 구간별 합을 여러 사람이 계산하고 마지막에 합치는 것과 같다. 단, 각 구간의 결과를 다음 구간 계산에 전달해야 한다.</p></div></div>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="griffin-최근-기억은-attention-긴-흐름은-recurrence">Griffin: 최근 기억은 attention, 긴 흐름은 recurrence<a href="https://ql.gl/ko/blog/dd8d73cd/#griffin-%EC%B5%9C%EA%B7%BC-%EA%B8%B0%EC%96%B5%EC%9D%80-attention-%EA%B8%B4-%ED%9D%90%EB%A6%84%EC%9D%80-recurrence" class="hash-link" aria-label="Griffin: 최근 기억은 attention, 긴 흐름은 recurrence에 대한 직접 링크" title="Griffin: 최근 기억은 attention, 긴 흐름은 recurrence에 대한 직접 링크" translate="no">​</a></h2>
<p>Griffin은 Hawk만 쌓은 모델이 아니다. 원문은 recurrent block과 local multi-query attention(MQA) block을 교대하는 구조를 설명한다. 구체적으로 recurrent block 두 개 뒤에 local attention을 사용하는 residual block을 배치하며, 기본 local attention window는 1024 tokens로 제시된다. 최근 1024토큰 안의 세밀한 관계는 어텐션이 직접 보고, 그보다 긴 흐름은 recurrence의 상태가 압축해 전달하는 그림이다.</p>
<p>이 조합은 단순한 평균이 아니다. local attention은 전역 KV cache보다 저장 범위가 작고, recurrence는 창 밖의 정보를 고정 상태로 넘긴다. 따라서 “긴 문맥을 전부 attention으로 본다”와 “모든 정보를 하나의 벡터로 압축한다” 사이의 설계 공간이 생긴다. 하지만 어떤 정보가 창 안에 남고 어떤 정보가 상태로 요약되는지는 학습 결과에 달려 있다. 긴 문서의 임의 위치를 정확히 인용해야 하는 시스템이라면 별도 평가가 필요하다.</p>
<p>논문은 residual pattern과 MLP block을 Transformer baseline과 공유한다고 설명한다. 이 점은 비교를 해석할 때 중요하다. 성능 차이가 recurrence와 local attention에서 왔더라도, 전체 블록·학습 레시피·데이터 구성이 동일한지는 표와 실험 절을 함께 확인해야 한다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="논문이-보고한-실험을-읽는-법">논문이 보고한 실험을 읽는 법<a href="https://ql.gl/ko/blog/dd8d73cd/#%EB%85%BC%EB%AC%B8%EC%9D%B4-%EB%B3%B4%EA%B3%A0%ED%95%9C-%EC%8B%A4%ED%97%98%EC%9D%84-%EC%9D%BD%EB%8A%94-%EB%B2%95" class="hash-link" aria-label="논문이 보고한 실험을 읽는 법에 대한 직접 링크" title="논문이 보고한 실험을 읽는 법에 대한 직접 링크" translate="no">​</a></h2>
<p>원문은 100M부터 7B까지 모델 크기를 바꾸고, 14B Griffin도 추가해 scaling curve를 제시한다. MassiveText 데이터셋, 2048 토큰 시퀀스, AdamW가 사용됐다고 기술한다. validation loss와 학습 FLOPs 관계에서 Griffin이 여러 예산 구간에서 자체 Transformer baseline보다 낮은 loss를 보였다고 보고하며, Hawk는 상대적으로 격차가 있으나 큰 예산에서 좁혀진다고 설명한다.</p>
<p>downstream 비교에서는 자체 MQA Transformer baseline과 Mamba-3B, Llama-2를 사용한다. Hawk-3B가 보고된 Mamba-3B보다 강한 결과를 보였고, Griffin-7B와 14B가 Llama-2와 경쟁적인 평균을 보였다는 것이 논문의 요지다. 하지만 외부 baseline은 서로 다른 데이터와 토큰 수로 학습됐다고 원문이 직접 주의를 준다. 특히 Llama-2와 Mamba가 Griffin보다 훨씬 많은 토큰을 보았다는 점은 결과를 읽을 때 반드시 함께 적어야 한다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="시스템-관점-빠른-한-토큰이-전체-서비스-비용을-결정한다">시스템 관점: 빠른 한 토큰이 전체 서비스 비용을 결정한다<a href="https://ql.gl/ko/blog/dd8d73cd/#%EC%8B%9C%EC%8A%A4%ED%85%9C-%EA%B4%80%EC%A0%90-%EB%B9%A0%EB%A5%B8-%ED%95%9C-%ED%86%A0%ED%81%B0%EC%9D%B4-%EC%A0%84%EC%B2%B4-%EC%84%9C%EB%B9%84%EC%8A%A4-%EB%B9%84%EC%9A%A9%EC%9D%84-%EA%B2%B0%EC%A0%95%ED%95%9C%EB%8B%A4" class="hash-link" aria-label="시스템 관점: 빠른 한 토큰이 전체 서비스 비용을 결정한다에 대한 직접 링크" title="시스템 관점: 빠른 한 토큰이 전체 서비스 비용을 결정한다에 대한 직접 링크" translate="no">​</a></h2>
<p>추론에서 Transformer의 비용은 context와 KV cache에 따라 커진다. Griffin의 recurrent block은 고정 크기 상태를 사용하고 local attention은 제한된 창을 사용하므로, 긴 시퀀스에서 메모리와 지연을 줄일 가능성이 있다. 논문은 낮은 latency와 높은 throughput을 보고하지만, 실제 값과 유리한 조건은 하드웨어·배치·시퀀스 길이·커널에 의존한다. 따라서 운영 환경에서는 평균 지연뿐 아니라 첫 토큰 지연, 토큰 간 지연, 동시성별 처리량, 상태 메모리까지 측정해야 한다.</p>
<p>학습 측면에서는 parallel scan과 local attention 모두 GPU 병렬성을 활용할 수 있다. 분산 학습에서는 14B 모델을 확장하고 shard 방법을 설명했다는 점이 실무적인 관심사다. 그렇다고 기존 Transformer 학습 스택을 그대로 재사용할 수 있다는 뜻은 아니다. recurrence state의 체크포인트, sequence parallel 통신, variable-length 배치 처리, fused kernel 지원을 구현 단계에서 검증해야 한다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="논문-구조-분석">논문 구조 분석<a href="https://ql.gl/ko/blog/dd8d73cd/#%EB%85%BC%EB%AC%B8-%EA%B5%AC%EC%A1%B0-%EB%B6%84%EC%84%9D" class="hash-link" aria-label="논문 구조 분석에 대한 직접 링크" title="논문 구조 분석에 대한 직접 링크" translate="no">​</a></h2>
<p>논문은 Introduction에서 RNN의 추론 장점과 학습 난점, Transformer의 표현력과 긴 시퀀스 비용을 대비한다. Background에서 선형 recurrence와 local attention의 구성 요소를 설명한 뒤 Hawk를 만들고, 두 블록을 섞어 Griffin을 정의한다. 이후 scaling, downstream, 긴 시퀀스 extrapolation, 속도·메모리 평가로 가는 문제→설계→검증 순서다. 결론은 모델이 경쟁적임을 강조하지만, 구조적 선택이 어떤 작업에 유리한지에 대한 해석은 실험 조건과 함께 읽어야 한다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="한계와-도입-전-체크리스트">한계와 도입 전 체크리스트<a href="https://ql.gl/ko/blog/dd8d73cd/#%ED%95%9C%EA%B3%84%EC%99%80-%EB%8F%84%EC%9E%85-%EC%A0%84-%EC%B2%B4%ED%81%AC%EB%A6%AC%EC%8A%A4%ED%8A%B8" class="hash-link" aria-label="한계와 도입 전 체크리스트에 대한 직접 링크" title="한계와 도입 전 체크리스트에 대한 직접 링크" translate="no">​</a></h2>
<p>첫째, local window가 최근 정보를 우선한다는 편향은 장거리의 정확한 회수 능력과 별개다. 둘째, recurrence 상태는 작지만 정보 압축의 손실 경로를 갖는다. 셋째, 논문의 강한 baseline 비교는 학습 토큰 수와 데이터셋이 같지 않은 경우가 있으므로 절대적인 우열로 번역하면 안 된다. 넷째, 논문이 보고한 속도 이점이 모든 추론 엔진에서 자동으로 나타나는 것은 아니다.</p>
<p>실험한다면 다음을 같은 조건으로 비교하는 것이 좋다.</p>
<ul>
<li class="">문맥 길이와 batch size별 prefill·decode 지연</li>
<li class="">사용자 수 증가에 따른 상태·KV 메모리 피크</li>
<li class="">최근 구간 질문과 장거리 associative recall을 분리한 정확도</li>
<li class="">동일 토큰 예산·데이터·튜닝 예산에서의 perplexity와 downstream 점수</li>
<li class="">체크포인트 복구와 스트리밍 입력에서 recurrent state의 일관성</li>
</ul>
<p>Griffin의 메시지는 RNN으로 돌아가자는 것이 아니다. 긴 범위를 요약하는 recurrence와 가까운 범위의 정확한 비교를 담당하는 attention을 한 모델 안에 배치해, 알고리즘적 효율과 표현력 사이의 경계를 조정하자는 제안이다. 제공된 자료에서 확인되는 성능은 유망하지만, 실제 도입 전에는 원문·코드·벤치마크를 확인해야 한다. 특히 서비스의 문맥 접근 패턴이 1024토큰 창과 상태 압축 가정에 맞는지가 먼저다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="sources">Sources<a href="https://ql.gl/ko/blog/dd8d73cd/#sources" class="hash-link" aria-label="Sources에 대한 직접 링크" title="Sources에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class="">Soham De et al., “Griffin: Mixing Gated Linear Recurrences with Local Attention for Efficient Language Models,” arXiv:2402.19427, submitted 2024-02-29, CC BY 4.0. <a href="https://arxiv.org/abs/2402.19427" target="_blank" rel="noopener noreferrer" class="">https://arxiv.org/abs/2402.19427</a></li>
<li class="">HTML full text, arXiv:2402.19427v1, sections 1–6, retrieved 2026-08-19. <a href="https://arxiv.org/html/2402.19427v1" target="_blank" rel="noopener noreferrer" class="">https://arxiv.org/html/2402.19427v1</a></li>
</ul>]]></content>
        <author>
            <name>p4r4d0xb0x</name>
            <uri>https://bdev.io</uri>
        </author>
        <category label="AI" term="AI"/>
        <category label="Research" term="Research"/>
        <category label="RNN" term="RNN"/>
        <category label="Attention" term="Attention"/>
        <category label="Efficient Inference" term="Efficient Inference"/>
    </entry>
    <entry>
        <title type="html"><![CDATA[RWKV-5 Eagle과 RWKV-6 Finch: 상태를 행렬로 키우고 recurrence를 동적으로 만들기]]></title>
        <id>https://ql.gl/ko/blog/2a987eb6/</id>
        <link href="https://ql.gl/ko/blog/2a987eb6/"/>
        <updated>2026-08-19T00:00:00.000Z</updated>
        <summary type="html"><![CDATA[Eagle과 Finch가 RWKV-4의 효율적 추론 경로를 유지하면서 행렬 상태, 다중 헤드, 데이터 의존적 recurrence를 추가한 과정을 원문 근거와 함께 해설한다.]]></summary>
        <content type="html"><![CDATA[<p><img decoding="async" loading="lazy" src="https://ql.gl/img/blog/rwkv-eagle-finch/cover.webp" alt="RWKV의 시간 혼합 블록과 행렬 상태 갱신을 표현한 개념도" class="img_ev3q"></p>
<p>Transformer가 긴 문맥을 처리하는 방식은 강력하지만, 생성할 때 과거 키와 값을 저장하고 읽는 비용이 따라온다. RWKV는 어텐션처럼 보이는 가중 평균을 recurrence로 계산해, 학습에서는 시간축 병렬화를 유지하고 생성에서는 토큰당 고정 크기 상태를 사용하는 방향을 택했다. “Eagle and Finch” 논문은 이 RWKV-4를 두 단계로 확장한다. Eagle(RWKV-5)은 벡터 상태를 다중 헤드 행렬 상태로 넓히고, Finch(RWKV-6)은 decay와 token shift를 입력에 따라 바꾼다.</p>
<p>원문 초록은 Eagle 네 모델(0.46B–7.5B)과 Finch 두 모델(1.6B, 3.1B)을 학습해 여러 벤치마크에서 경쟁적인 성능을 보였다고 보고한다. 또 1.12조 토큰 규모의 다국어 코퍼스, greedy matching 기반 토크나이저, Apache 2.0으로 공개된 모델과 코드를 소개한다. 이 글은 arXiv 2404.05892v4의 구조와 초록을 바탕으로 하며, “경쟁적”이라는 표현을 특정 모델의 보편적 우승으로 확대하지 않는다.</p>
<!-- -->
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="rwkv-4의-출발점-어텐션을-감쇠-recurrence로-바꾸기">RWKV-4의 출발점: 어텐션을 감쇠 recurrence로 바꾸기<a href="https://ql.gl/ko/blog/2a987eb6/#rwkv-4%EC%9D%98-%EC%B6%9C%EB%B0%9C%EC%A0%90-%EC%96%B4%ED%85%90%EC%85%98%EC%9D%84-%EA%B0%90%EC%87%A0-recurrence%EB%A1%9C-%EB%B0%94%EA%BE%B8%EA%B8%B0" class="hash-link" aria-label="RWKV-4의 출발점: 어텐션을 감쇠 recurrence로 바꾸기에 대한 직접 링크" title="RWKV-4의 출발점: 어텐션을 감쇠 recurrence로 바꾸기에 대한 직접 링크" translate="no">​</a></h2>
<p>RWKV의 시간 혼합(time mixing)은 과거의 key-value 정보를 decay와 함께 누적한다. 현재 입력에는 별도의 bonus를 주고, receptance가 누적된 값을 얼마나 읽을지 조절한다. 이를 선형 어텐션의 <code>k^T v</code> 상태 업데이트와 비교하면 직관이 선명해진다. 매 단계에서 과거를 전부 다시 보지 않고, 누적된 상태와 현재 query에 해당하는 receptance만 계산한다.</p>
<p>이 구조의 시스템적 장점은 두 계산 모드다. 전체 시퀀스를 학습할 때는 time-parallel 구현으로 병렬화하고, 한 토큰씩 생성할 때는 상태를 갱신한다. 원문 표는 RWKV-4/5/6이 추론에서 시퀀스 길이에 대해 O(1) 상태와 시간 비용을 갖는 계열로 설명한다. 다만 O(1)은 모델 차원과 헤드 수를 무시한 표기이며, 실제 속도는 행렬 곱, 메모리 접근, 커널 구현에 의해 결정된다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: recurrence</div><div class="admonitionContent_BuS1"><p>쉬운 정의: 현재 결과를 계산한 뒤 그 결과의 일부를 다음 입력 처리에 다시 사용하는 순환 계산이다.</p><p>예시: 장부의 잔액을 매일 새로 계산하지 않고, 어제 잔액에 오늘의 입출금만 반영하는 방식이다. 계산은 빠르지만 이전 기록을 잔액 하나로 요약해야 한다.</p></div></div>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: decay</div><div class="admonitionContent_BuS1"><p>쉬운 정의: 시간이 지날수록 과거 상태의 영향력을 줄이는 학습 가능한 감쇠 계수다.</p><p>예시: 칠판의 오래된 메모를 매 수업 조금씩 흐리게 만들어 최근 내용이 더 잘 보이게 하는 것과 같다. 너무 빨리 흐리면 장기 정보가 사라진다.</p></div></div>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="eagle-벡터-기억을-행렬-기억으로-확장">Eagle: 벡터 기억을 행렬 기억으로 확장<a href="https://ql.gl/ko/blog/2a987eb6/#eagle-%EB%B2%A1%ED%84%B0-%EA%B8%B0%EC%96%B5%EC%9D%84-%ED%96%89%EB%A0%AC-%EA%B8%B0%EC%96%B5%EC%9C%BC%EB%A1%9C-%ED%99%95%EC%9E%A5" class="hash-link" aria-label="Eagle: 벡터 기억을 행렬 기억으로 확장에 대한 직접 링크" title="Eagle: 벡터 기억을 행렬 기억으로 확장에 대한 직접 링크" translate="no">​</a></h2>
<p>Eagle의 가장 큰 변화는 각 헤드가 벡터가 아니라 행렬 형태의 <code>k^T v</code> 상태를 유지한다는 점이다. 원문은 multi-headed matrix-valued states, head별 LayerNorm, SiLU attention gating, receptance sigmoid 제거를 주요 변경으로 설명한다. 상태 갱신은 대략 다음처럼 읽을 수 있다.</p>
<div class="language-text codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#f8f8f2;--prism-background-color:#272822"><div class="codeBlockContent_QJqH"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar" style="color:#f8f8f2;background-color:#272822"><code class="codeBlockLines_e6Vv"><div class="token-line" style="color:#f8f8f2"><span class="token plain">s' = diag(w) · s + k^T · v</span><br></div><div class="token-line" style="color:#f8f8f2"><span class="token plain">wkv' = s + diag(u) · k^T · v</span><br></div></code></pre></div></div>
<p><code>w</code>는 <code>exp(-exp(ω))</code>로 매개변수화되어 각 채널의 감쇠값이 0과 1 사이에 놓이도록 한다고 원문은 설명한다. 현재 토큰의 기여에는 <code>u</code>를 곱해 과거 누적값과 다른 가중치를 준다. receptance는 query처럼 상태를 읽고, SiLU gate는 출력의 흐름을 조절한다. 이 설계는 상태가 단순한 채널별 합이 아니라 key와 value의 관계를 더 풍부하게 보존하도록 만든다.</p>
<p>여기서 “표현력이 커졌다”는 말은 상태의 자유도가 늘고 입력·출력 변환이 다양해졌다는 구조적 해석이다. 특정 작업에서 반드시 정확도가 상승한다는 보장은 아니다. 원문은 Eagle과 Finch를 여러 벤치마크에서 평가하지만, 애플리케이션마다 상태 크기와 데이터 분포의 적합성이 달라질 수 있다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: matrix-valued state</div><div class="admonitionContent_BuS1"><p>쉬운 정의: 과거 정보를 숫자 하나나 벡터 하나가 아니라 행과 열의 관계를 가진 행렬로 누적하는 내부 상태다.</p><p>예시: 사람별 목록만 보관하는 대신 ‘사람-역할’ 표를 유지하는 것이다. 어떤 사람이 어떤 역할과 연결되는지 더 풍부하게 표현할 수 있지만 저장과 계산은 늘어난다.</p></div></div>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="finch-recurrence를-입력에-반응시키기">Finch: recurrence를 입력에 반응시키기<a href="https://ql.gl/ko/blog/2a987eb6/#finch-recurrence%EB%A5%BC-%EC%9E%85%EB%A0%A5%EC%97%90-%EB%B0%98%EC%9D%91%EC%8B%9C%ED%82%A4%EA%B8%B0" class="hash-link" aria-label="Finch: recurrence를 입력에 반응시키기에 대한 직접 링크" title="Finch: recurrence를 입력에 반응시키기에 대한 직접 링크" translate="no">​</a></h2>
<p>Finch는 Eagle의 기반 위에서 token shift와 decay를 데이터 의존적으로 바꾼다. Eagle의 token shift가 현재와 이전 입력을 학습 가능한 선형 보간으로 섞는다면, Finch는 여기에 입력으로부터 계산한 추가 보정을 넣는다. 원문은 LoRA 형태를 활용해 decay 벡터를 문맥에 따라 보정하는 방법도 제시한다. 따라서 같은 채널이라도 입력 상황에 따라 과거를 얼마나 오래 유지할지 달라질 수 있다.</p>
<p>이 변화는 고정 decay의 한계를 겨냥한다. 어떤 정보는 짧게 기억하고, 어떤 정보는 긴 문맥을 통해 전달해야 한다. 동적 recurrence는 그 선택을 데이터에 맡긴다. 동시에 구현 복잡도와 안정성, 병렬 학습 비용이 커질 가능성이 있다. 논문은 구체적 공식을 제시하지만, 모든 하드웨어에서 동적 경로가 고정 경로만큼 효율적이라는 의미는 아니다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="다국어-데이터와-토크나이저도-아키텍처의-일부다">다국어 데이터와 토크나이저도 아키텍처의 일부다<a href="https://ql.gl/ko/blog/2a987eb6/#%EB%8B%A4%EA%B5%AD%EC%96%B4-%EB%8D%B0%EC%9D%B4%ED%84%B0%EC%99%80-%ED%86%A0%ED%81%AC%EB%82%98%EC%9D%B4%EC%A0%80%EB%8F%84-%EC%95%84%ED%82%A4%ED%85%8D%EC%B2%98%EC%9D%98-%EC%9D%BC%EB%B6%80%EB%8B%A4" class="hash-link" aria-label="다국어 데이터와 토크나이저도 아키텍처의 일부다에 대한 직접 링크" title="다국어 데이터와 토크나이저도 아키텍처의 일부다에 대한 직접 링크" translate="no">​</a></h2>
<p>이 논문은 블록 수식만 다루지 않는다. RWKV World v2라는 1.12조 토큰 규모의 공개 다국어 데이터와 RWKV World Tokenizer를 소개한다. 토크나이저는 Trie 기반 greedy matching으로 설명되며, 저자들은 저대표 언어와 코드 데이터를 더 잘 다루는 것을 목표로 한다. 모델 성능을 아키텍처만의 결과로 읽으면 안 되는 이유다. 데이터 구성, 토큰화 효율, 학습 토큰 수가 함께 결과를 만든다.</p>
<p>원문은 네 개의 Eagle 모델과 두 개의 Finch 모델을 학습하고, 영어·다국어 텍스트, associative recall, 음악, 비전-언어 등 여러 영역을 평가한다. 표에 나타난 benchmark 점수는 모델 크기·학습 데이터·평가 프로토콜을 함께 봐야 한다. 다국어 서비스에 적용하려면 한국어와 목표 언어에서 토큰당 정보량, 긴 문장 회수, 코드 혼합 입력을 별도로 측정해야 한다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="논문-구조-분석과-실무-해석">논문 구조 분석과 실무 해석<a href="https://ql.gl/ko/blog/2a987eb6/#%EB%85%BC%EB%AC%B8-%EA%B5%AC%EC%A1%B0-%EB%B6%84%EC%84%9D%EA%B3%BC-%EC%8B%A4%EB%AC%B4-%ED%95%B4%EC%84%9D" class="hash-link" aria-label="논문 구조 분석과 실무 해석에 대한 직접 링크" title="논문 구조 분석과 실무 해석에 대한 직접 링크" translate="no">​</a></h2>
<p>원문은 Introduction에서 Transformer의 quadratic attention과 RNN의 추론 효율을 대비하고, Background에서 linear attention·AFT·RWKV-4의 진화를 설명한다. 이후 Eagle/Finch architecture, 세부 method, tokenizer와 dataset, pretrained models, language modeling·속도·멀티모달 실험 순서로 진행된다. 즉 기존 구조의 병목을 정의하고, Eagle→Finch의 단계적 변경을 제시한 뒤, 데이터·모델·응용 범위까지 검증하는 흐름이다.</p>
<p>운영 관점에서 RWKV의 핵심은 “긴 문맥을 무한히 저장한다”가 아니라 상태를 고정 크기로 유지하며 스트리밍 처리하기 쉽다는 점이다. 장시간 입력을 다루는 에이전트나 로컬 추론에서는 KV cache보다 상태 메모리 모델이 단순해질 수 있다. 반면 상태를 재사용하거나 분기할 때 특정 과거 토큰을 정확히 다시 읽는 Transformer식 접근과 다르다. 체크포인트 사이의 상태 호환성, 배치 내 길이 차이, 상태 초기화 정책을 제품 설계에서 명시해야 한다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="한계와-확인해야-할-것">한계와 확인해야 할 것<a href="https://ql.gl/ko/blog/2a987eb6/#%ED%95%9C%EA%B3%84%EC%99%80-%ED%99%95%EC%9D%B8%ED%95%B4%EC%95%BC-%ED%95%A0-%EA%B2%83" class="hash-link" aria-label="한계와 확인해야 할 것에 대한 직접 링크" title="한계와 확인해야 할 것에 대한 직접 링크" translate="no">​</a></h2>
<p>첫째, 논문의 “competitive performance”는 광범위한 평가를 뜻하지만 모든 모델·언어·작업에서 Transformer를 능가한다는 주장은 아니다. 둘째, Apache 2.0 모델 공개는 재현 가능성을 높이지만, 데이터셋의 실제 구성과 사용 조건은 원문과 배포 저장소에서 다시 확인해야 한다. 셋째, O(1) 추론 표기는 시퀀스 길이에 대한 복잡도이며, 행렬 상태가 커질 때 절대 메모리와 연산량이 작다는 보장은 없다. 넷째, 동적 decay가 장기 기억을 자동으로 해결하지 않는다. 보존과 망각의 균형은 평가 데이터에 의존한다.</p>
<p>도입 전에는 다음을 확인할 필요가 있다.</p>
<ul>
<li class="">목표 언어와 코드에서 토크나이저의 평균 토큰 수</li>
<li class="">동일 batch·정밀도·하드웨어에서 prefill 및 decode 처리량</li>
<li class="">상태 크기와 동시 요청 수에 따른 메모리 피크</li>
<li class="">최근 기억, 장거리 회수, 순서 변경에 대한 별도 정확도</li>
<li class="">공개 inference/training 코드와 모델 체크포인트의 버전·라이선스</li>
</ul>
<p>Eagle과 Finch가 보여 주는 방향은 RNN과 Transformer 중 하나를 선언하는 것이 아니다. 상태를 행렬로 풍부하게 만들고 recurrence의 감쇠를 입력에 반응시키면서도, 생성 단계에서는 상태 기반 효율을 지키려는 점진적 설계다. 제공된 자료에서 확인되는 범위에서는 매력적인 대안이지만, 실제 성능과 비용은 모델 크기·토크나이저·커널·업무 문맥을 함께 측정해야 한다. 특히 “무한 문맥”이라는 표현보다, 고정 크기 상태가 어떤 정보를 보존하고 어떤 정보를 버리는지부터 검증하는 편이 안전하다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="sources">Sources<a href="https://ql.gl/ko/blog/2a987eb6/#sources" class="hash-link" aria-label="Sources에 대한 직접 링크" title="Sources에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class="">Bo Peng et al., “Eagle and Finch: RWKV with Matrix-Valued States and Dynamic Recurrence,” arXiv:2404.05892v4, submitted 2024-04-08, revised 2024-09-26, CC BY 4.0. <a href="https://arxiv.org/abs/2404.05892" target="_blank" rel="noopener noreferrer" class="">https://arxiv.org/abs/2404.05892</a></li>
<li class="">HTML full text, arXiv:2404.05892v4, sections 1–9 and appendices, retrieved 2026-08-19. <a href="https://arxiv.org/html/2404.05892v4" target="_blank" rel="noopener noreferrer" class="">https://arxiv.org/html/2404.05892v4</a></li>
<li class="">RWKV project links listed by the paper (models, training, inference); availability and license should be rechecked before deployment. <a href="https://huggingface.co/RWKV" target="_blank" rel="noopener noreferrer" class="">https://huggingface.co/RWKV</a></li>
</ul>]]></content>
        <author>
            <name>p4r4d0xb0x</name>
            <uri>https://bdev.io</uri>
        </author>
        <category label="AI" term="AI"/>
        <category label="Research" term="Research"/>
        <category label="RWKV" term="RWKV"/>
        <category label="RNN" term="RNN"/>
        <category label="Multilingual" term="Multilingual"/>
    </entry>
    <entry>
        <title type="html"><![CDATA[xLSTM: 순환 메모리를 다시 확장하는 방법]]></title>
        <id>https://ql.gl/ko/blog/4d111147/</id>
        <link href="https://ql.gl/ko/blog/4d111147/"/>
        <updated>2026-08-19T00:00:00.000Z</updated>
        <summary type="html"><![CDATA[xLSTM은 LSTM의 게이팅과 메모리 구조를 현대 언어 모델의 스케일링 관점에서 다시 설계한다. 공개 초록과 메타데이터를 바탕으로 sLSTM·mLSTM의 역할, 병렬화와 메모리 상태의 의미, 그리고 확인되지 않은 성능 조건을 정리한다.]]></summary>
        <content type="html"><![CDATA[<p>LSTM은 긴 의존성을 다루기 위해 게이트와 메모리를 도입했지만, 대규모 언어 모델의 시대에는 Transformer의 병렬 self-attention에 밀려났다. xLSTM의 질문은 단순하다. LSTM을 폐기하지 않고, 현대적인 안정화 기법과 하드웨어 친화적 계산을 결합하면 수십억 파라미터 규모에서도 경쟁 가능한가? 논문 초록이 제시하는 답은 “기존 LSTM을 그대로 키우는 것”이 아니라, 게이팅과 메모리 업데이트 자체를 확장하는 것이다.</p>
<p><img decoding="async" loading="lazy" src="https://ql.gl/img/blog/xlstm-recurrent-memory/cover.webp" alt="순환 메모리 셀과 행렬 상태가 연결된 xLSTM 개념도" class="img_ev3q"></p>
<!-- -->
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="문제-순환성은-기억을-주지만-확장을-어렵게-한다">문제: 순환성은 기억을 주지만 확장을 어렵게 한다<a href="https://ql.gl/ko/blog/4d111147/#%EB%AC%B8%EC%A0%9C-%EC%88%9C%ED%99%98%EC%84%B1%EC%9D%80-%EA%B8%B0%EC%96%B5%EC%9D%84-%EC%A3%BC%EC%A7%80%EB%A7%8C-%ED%99%95%EC%9E%A5%EC%9D%84-%EC%96%B4%EB%A0%B5%EA%B2%8C-%ED%95%9C%EB%8B%A4" class="hash-link" aria-label="문제: 순환성은 기억을 주지만 확장을 어렵게 한다에 대한 직접 링크" title="문제: 순환성은 기억을 주지만 확장을 어렵게 한다에 대한 직접 링크" translate="no">​</a></h2>
<p>일반적인 순환 모델은 토큰을 한 번에 처리하면서 이전 시점의 상태를 다음 시점으로 전달한다. 이 구조는 과거 전체를 매번 다시 읽지 않아도 된다는 장점이 있다. 반면 시간축의 의존성 때문에 학습 병렬화가 제한되고, 단순한 메모리 상태는 다양한 정보를 동시에 보존하기 어렵다. Transformer는 attention으로 여러 위치를 직접 연결해 이 문제를 풀었지만, 긴 입력에서 KV cache와 메모리 사용량이 커진다.</p>
<p>xLSTM은 이 대립을 “순환 모델 대 Transformer”라는 이분법으로만 보지 않는다. 핵심은 LSTM의 안정적인 기억 장치를 보존하면서, 학습 시 병렬화 가능한 경로와 더 풍부한 상태 표현을 함께 확보하는 것이다. 공개 초록에서 확인되는 기여는 세 축이다. 첫째, 지수 게이팅과 정규화·안정화 기법이다. 둘째, 스칼라 메모리를 쓰는 sLSTM과 행렬 메모리를 쓰는 mLSTM이다. 셋째, 이 셀들을 residual block backbone 안에 넣고 xLSTM block과 아키텍처로 쌓는 방식이다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="핵심-메커니즘">핵심 메커니즘<a href="https://ql.gl/ko/blog/4d111147/#%ED%95%B5%EC%8B%AC-%EB%A9%94%EC%BB%A4%EB%8B%88%EC%A6%98" class="hash-link" aria-label="핵심 메커니즘에 대한 직접 링크" title="핵심 메커니즘에 대한 직접 링크" translate="no">​</a></h2>
<h3 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="1-지수-게이팅과-안정화">1. 지수 게이팅과 안정화<a href="https://ql.gl/ko/blog/4d111147/#1-%EC%A7%80%EC%88%98-%EA%B2%8C%EC%9D%B4%ED%8C%85%EA%B3%BC-%EC%95%88%EC%A0%95%ED%99%94" class="hash-link" aria-label="1. 지수 게이팅과 안정화에 대한 직접 링크" title="1. 지수 게이팅과 안정화에 대한 직접 링크" translate="no">​</a></h3>
<p>LSTM의 게이트는 입력을 얼마나 쓰고 이전 상태를 얼마나 유지할지를 조절한다. xLSTM은 게이트를 지수 형태로 확장한다. 지수 함수는 작은 입력 차이도 큰 비율 차이로 바꿀 수 있으므로 표현력 있는 선택 규칙을 만들 수 있지만, 동시에 값이 폭발하거나 소실될 위험이 있다. 그래서 논문은 적절한 정규화와 안정화 기법을 함께 도입한다고 설명한다. 중요한 점은 “지수 게이팅만 넣으면 좋아진다”가 아니라, 게이팅의 동적 범위를 제어하는 설계가 한 묶음이라는 것이다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 게이팅(gating)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 신경망이 지금 들어온 정보와 예전에 기억한 정보 중 무엇을 얼마나 통과시킬지 정하는 조절 장치다.</p><p>예시: 요리사가 냄비에 새 재료를 넣을 때, 이미 익은 재료의 맛을 얼마나 남기고 새 재료를 얼마나 섞을지 조절하는 밸브와 비슷하다.</p></div></div>
<h3 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="2-slstm-스칼라-상태의-확장">2. sLSTM: 스칼라 상태의 확장<a href="https://ql.gl/ko/blog/4d111147/#2-slstm-%EC%8A%A4%EC%B9%BC%EB%9D%BC-%EC%83%81%ED%83%9C%EC%9D%98-%ED%99%95%EC%9E%A5" class="hash-link" aria-label="2. sLSTM: 스칼라 상태의 확장에 대한 직접 링크" title="2. sLSTM: 스칼라 상태의 확장에 대한 직접 링크" translate="no">​</a></h3>
<p>sLSTM은 스칼라 메모리와 스칼라 업데이트를 사용하면서 새로운 memory mixing을 추가한다. 여기서 중요한 해석은 기존 구조를 단순히 넓히는 것이 아니다. 여러 정보 흐름을 섞는 방법을 바꿔, 제한된 상태라도 더 유연하게 갱신하려는 설계다. 다만 공개 초록만으로는 mixing의 정확한 수식, 게이트 파라미터화, 안정화 항의 구현 위치까지 확인할 수 없다. 따라서 이 글에서는 sLSTM을 “세부 수식이 검증된 구현”이 아니라 논문이 제안한 구조적 축으로 다룬다.</p>
<h3 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="3-mlstm-행렬-메모리와-공분산-업데이트">3. mLSTM: 행렬 메모리와 공분산 업데이트<a href="https://ql.gl/ko/blog/4d111147/#3-mlstm-%ED%96%89%EB%A0%AC-%EB%A9%94%EB%AA%A8%EB%A6%AC%EC%99%80-%EA%B3%B5%EB%B6%84%EC%82%B0-%EC%97%85%EB%8D%B0%EC%9D%B4%ED%8A%B8" class="hash-link" aria-label="3. mLSTM: 행렬 메모리와 공분산 업데이트에 대한 직접 링크" title="3. mLSTM: 행렬 메모리와 공분산 업데이트에 대한 직접 링크" translate="no">​</a></h3>
<p>mLSTM은 메모리를 행렬로 만들고 covariance update rule을 사용한다. 스칼라 상태가 한 종류의 요약값을 전달한다면, 행렬 상태는 입력 특징 사이의 관계를 저장할 여지가 더 크다. 공분산 업데이트라는 표현은 새 입력과 기존 상태의 관계를 통계적 구조처럼 누적한다는 방향을 가리킨다. 이 선택은 context에서 반복되는 패턴이나 연관성을 기억하는 데 유리할 수 있지만, 상태 차원과 연산량이 늘어날 가능성도 함께 고려해야 한다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 공분산 업데이트(covariance update)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 두 정보가 함께 변하는 관계를 기록하고, 새 관측이 들어올 때 그 기록을 갱신하는 방법이다.</p><p>예시: 우산 판매량과 비 오는 날의 관계를 매일 기록해, 오늘 비가 오면 판매량 예측을 조정하는 표와 비슷하다.</p></div></div>
<h3 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="4-residual-block으로의-통합">4. residual block으로의 통합<a href="https://ql.gl/ko/blog/4d111147/#4-residual-block%EC%9C%BC%EB%A1%9C%EC%9D%98-%ED%86%B5%ED%95%A9" class="hash-link" aria-label="4. residual block으로의 통합에 대한 직접 링크" title="4. residual block으로의 통합에 대한 직접 링크" translate="no">​</a></h3>
<p>xLSTM cell은 독립적인 옛날식 순환 레이어가 아니라 residual block backbone에 통합된다. 잔차 연결은 입력을 변환 경로와 건너뛰기 경로로 나누어 깊은 네트워크에서 정보와 그래디언트가 흐를 길을 남긴다. 이 통합은 LSTM의 메모리 업데이트를 현대적인 깊은 모델의 스택 구조에 넣기 위한 실용적 장치다. 논문 제목과 초록은 이 구성이 성능과 스케일링에서 Transformer와 SSM에 호의적으로 비교된다고 보고하지만, 비교의 세부 조건과 수치는 이 메타데이터만으로 확정할 수 없다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="논문의-주장과-증거-범위">논문의 주장과 증거 범위<a href="https://ql.gl/ko/blog/4d111147/#%EB%85%BC%EB%AC%B8%EC%9D%98-%EC%A3%BC%EC%9E%A5%EA%B3%BC-%EC%A6%9D%EA%B1%B0-%EB%B2%94%EC%9C%84" class="hash-link" aria-label="논문의 주장과 증거 범위에 대한 직접 링크" title="논문의 주장과 증거 범위에 대한 직접 링크" translate="no">​</a></h2>
<p>논문은 1990년대 LSTM의 constant error carousel과 게이팅에서 출발해, Transformer가 만든 병렬화 중심의 흐름을 배경으로 제시한다. 이후 방법론에서는 지수 게이팅, sLSTM, mLSTM, xLSTM block을 소개하고, 실험에서는 이 확장들이 최신 Transformer 및 State Space Model과 성능·스케일링 측면에서 유리하게 비교된다고 초록에서 요약한다. 이는 논문이 실험을 수행했다고 말하는 근거는 되지만, 어떤 데이터셋·하드웨어·모델 크기·통계적 유의성으로 결론을 얻었는지는 원문 본문과 코드 검토가 필요하다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="실무적-함의">실무적 함의<a href="https://ql.gl/ko/blog/4d111147/#%EC%8B%A4%EB%AC%B4%EC%A0%81-%ED%95%A8%EC%9D%98" class="hash-link" aria-label="실무적 함의에 대한 직접 링크" title="실무적 함의에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class=""><strong>추론 상태</strong>: 순환 모델은 토큰별 상태를 유지하므로 긴 입력에서 attention의 전체 KV cache와 다른 메모리·대역폭 특성을 가질 수 있다. 그러나 실제 이점은 상태 크기, 커널 구현, 배치 크기에 좌우된다.</li>
<li class=""><strong>학습 병렬화</strong>: mLSTM의 fully parallelizable 성격은 순환 모델의 약점인 학습 직렬성을 줄이려는 방향이다. 이것이 모든 길이와 하드웨어에서 같은 처리량을 보장한다는 뜻은 아니다.</li>
<li class=""><strong>평가 설계</strong>: 단순 perplexity만으로는 메모리 구조의 가치를 판단하기 어렵다. 장거리 기억, 상태 추적, 긴 컨텍스트, 재사용되는 패턴을 분리해 평가해야 한다.</li>
</ul>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="한계와-남은-질문">한계와 남은 질문<a href="https://ql.gl/ko/blog/4d111147/#%ED%95%9C%EA%B3%84%EC%99%80-%EB%82%A8%EC%9D%80-%EC%A7%88%EB%AC%B8" class="hash-link" aria-label="한계와 남은 질문에 대한 직접 링크" title="한계와 남은 질문에 대한 직접 링크" translate="no">​</a></h2>
<p>이 초안은 arXiv 초록과 메타데이터에 근거한다. 공개 범위에서 확인되지 않는 사항은 세부 게이트 수식, 정확한 벤치마크 수치, 학습 비용, 특정 GPU에서의 latency, 긴 문맥에서의 메모리 사용량이다. “Transformer를 대체한다”는 결론은 이 자료만으로는 정당화되지 않는다. 실제 도입 전에는 원문 방법론·실험 표·공개 코드의 재현 조건을 확인해야 한다. 특히 행렬 메모리가 제공하는 표현력과 상태 업데이트 비용 사이의 균형은 모델 크기별로 다시 측정해야 한다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="sources">Sources<a href="https://ql.gl/ko/blog/4d111147/#sources" class="hash-link" aria-label="Sources에 대한 직접 링크" title="Sources에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class=""><a href="https://arxiv.org/abs/2405.04517" target="_blank" rel="noopener noreferrer" class="">xLSTM: Extended Long Short-Term Memory</a> — license: <code>unknown</code>, retrieved: <code>2026-08-19</code>, source type: <code>original</code></li>
<li class="">Image: Placeholder — original technical cover to be created — license: <code>placeholder-original</code></li>
</ul>]]></content>
        <author>
            <name>p4r4d0xb0x</name>
            <uri>https://bdev.io</uri>
        </author>
        <category label="AI" term="AI"/>
        <category label="Deep Learning" term="Deep Learning"/>
        <category label="Recurrent Model" term="Recurrent Model"/>
        <category label="Research" term="Research"/>
        <category label="Explainer" term="Explainer"/>
    </entry>
    <entry>
        <title type="html"><![CDATA[Mamba-3: 선형 추론을 실제 시퀀스 모델링 품질로 연결하기]]></title>
        <id>https://ql.gl/ko/blog/14e25d3e/</id>
        <link href="https://ql.gl/ko/blog/14e25d3e/"/>
        <updated>2026-08-19T00:00:00.000Z</updated>
        <summary type="html"><![CDATA[Mamba-3는 상태공간 관점에서 재귀식, 복소 상태 업데이트, MIMO 입력·출력을 개선해 효율성과 상태 추적 능력을 함께 높이려 한다. 논문 초록에 명시된 1.5B 결과를 중심으로 설계와 증거의 경계를 분석한다.]]></summary>
        <content type="html"><![CDATA[<p>긴 컨텍스트를 처리할 때 Transformer의 비용은 attention 계산의 증가와 KV cache의 메모리 부담으로 나타난다. 선형 모델은 이론상 더 나은 비용 구조를 제공하지만, 상태 추적과 하드웨어 효율에서 품질을 잃기 쉽다. Mamba-3가 겨냥하는 간극은 바로 여기다. 논문은 “선형 복잡도”라는 표어보다 추론 시 실제 데이터 이동과 상태 표현이 중요하다는 관점에서, 재귀식과 상태 업데이트를 다시 설계한다.</p>
<p><img decoding="async" loading="lazy" src="https://ql.gl/img/blog/mamba3-improved-sequence-modeling/cover.webp" alt="상태공간 재귀와 다중 입력·출력 경로를 표현한 Mamba-3 개념도" class="img_ev3q"></p>
<!-- -->
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="선형이라고-충분하지-않은-이유">선형이라고 충분하지 않은 이유<a href="https://ql.gl/ko/blog/14e25d3e/#%EC%84%A0%ED%98%95%EC%9D%B4%EB%9D%BC%EA%B3%A0-%EC%B6%A9%EB%B6%84%ED%95%98%EC%A7%80-%EC%95%8A%EC%9D%80-%EC%9D%B4%EC%9C%A0" class="hash-link" aria-label="선형이라고 충분하지 않은 이유에 대한 직접 링크" title="선형이라고 충분하지 않은 이유에 대한 직접 링크" translate="no">​</a></h2>
<p>상태공간모델(SSM)은 입력 시퀀스를 고정 크기 상태로 압축하고, 각 시점의 상태를 갱신하면서 출력을 만든다. 이상적인 설명에서는 시퀀스 길이에 따라 계산량이 선형으로 증가하고, 디코딩 때 필요한 상태가 일정하다는 장점이 있다. 그러나 상태가 너무 단순하면 “몇 번째 항목이 어떤 값이었는가” 같은 상태 추적 과제를 놓칠 수 있다. 또한 이론적 연산량과 GPU에서 실제로 빠르게 실행되는지는 별개의 문제다. 작은 재귀 업데이트가 많은 메모리 읽기·쓰기를 일으키면, 산술 연산이 적어도 하드웨어 활용률이 낮아질 수 있다.</p>
<p>Mamba-3의 출발점은 inference-first다. 즉 학습만 편리한 구조가 아니라, 토큰을 하나씩 생성하는 decode 경로의 latency와 상태 크기를 설계 목표의 중심에 둔다. 초록에서 제시한 세 가지 방법론적 개선은 서로 다른 병목을 겨냥한다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="세-가지-개선">세 가지 개선<a href="https://ql.gl/ko/blog/14e25d3e/#%EC%84%B8-%EA%B0%80%EC%A7%80-%EA%B0%9C%EC%84%A0" class="hash-link" aria-label="세 가지 개선에 대한 직접 링크" title="세 가지 개선에 대한 직접 링크" translate="no">​</a></h2>
<h3 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="1-ssm-이산화에서-나온-표현력-있는-재귀">1. SSM 이산화에서 나온 표현력 있는 재귀<a href="https://ql.gl/ko/blog/14e25d3e/#1-ssm-%EC%9D%B4%EC%82%B0%ED%99%94%EC%97%90%EC%84%9C-%EB%82%98%EC%98%A8-%ED%91%9C%ED%98%84%EB%A0%A5-%EC%9E%88%EB%8A%94-%EC%9E%AC%EA%B7%80" class="hash-link" aria-label="1. SSM 이산화에서 나온 표현력 있는 재귀에 대한 직접 링크" title="1. SSM 이산화에서 나온 표현력 있는 재귀에 대한 직접 링크" translate="no">​</a></h3>
<p>첫 번째는 SSM 이산화(discretization)에서 유도한 더 표현력 있는 recurrence다. 연속시간 시스템을 토큰 단위 업데이트로 바꾸는 과정은 시간 간격과 상태 전이를 결정한다. 이 전이를 단순한 고정 규칙으로 두는 대신, Mamba-3는 상태가 입력을 더 세밀하게 누적하도록 재귀식을 확장한다. 초록만으로는 각 계수의 수식이나 학습 파라미터를 단정할 수 없지만, 방향은 명확하다. “선형 모델의 비용”을 유지하면서 “상태를 표현하는 방식”을 개선하는 것이다.</p>
<h3 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="2-복소수-상태-업데이트">2. 복소수 상태 업데이트<a href="https://ql.gl/ko/blog/14e25d3e/#2-%EB%B3%B5%EC%86%8C%EC%88%98-%EC%83%81%ED%83%9C-%EC%97%85%EB%8D%B0%EC%9D%B4%ED%8A%B8" class="hash-link" aria-label="2. 복소수 상태 업데이트에 대한 직접 링크" title="2. 복소수 상태 업데이트에 대한 직접 링크" translate="no">​</a></h3>
<p>두 번째는 complex-valued state update rule이다. 복소수 상태는 크기와 위상이라는 두 종류의 정보를 이용할 수 있어, 반복·주기·순서 관계를 표현할 여지를 넓힌다. 상태 추적처럼 위치와 변화가 중요한 과제에서 이 표현은 특히 의미가 있다. 다만 복소수 연산이 모든 하드웨어에서 동일하게 효율적인 것은 아니다. 구현이 실수부·허수부의 두 경로로 분해되는지, 커널이 얼마나 융합되는지에 따라 실측 latency가 달라진다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 상태공간모델(SSM)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 긴 입력을 전부 보관하는 대신, 지금까지 중요한 내용을 작은 상태에 계속 요약해 다음 출력에 사용하는 모델이다.</p><p>예시: 긴 영화를 매 장면 다시 보는 대신, 줄거리 노트 한 장을 계속 업데이트하며 다음 장면을 이해하는 방식이다.</p></div></div>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 이산화(discretization)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 연속적으로 변하는 시스템의 규칙을 컴퓨터가 한 단계씩 계산할 수 있는 규칙으로 바꾸는 과정이다.</p><p>예시: 자동차의 속도 변화를 매 순간 계산하는 대신, 1초마다 위치와 속도를 기록하는 표로 바꾸는 것과 같다.</p></div></div>
<h3 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="3-mimo-decode-latency를-늘리지-않는-다중-입출력">3. MIMO: decode latency를 늘리지 않는 다중 입출력<a href="https://ql.gl/ko/blog/14e25d3e/#3-mimo-decode-latency%EB%A5%BC-%EB%8A%98%EB%A6%AC%EC%A7%80-%EC%95%8A%EB%8A%94-%EB%8B%A4%EC%A4%91-%EC%9E%85%EC%B6%9C%EB%A0%A5" class="hash-link" aria-label="3. MIMO: decode latency를 늘리지 않는 다중 입출력에 대한 직접 링크" title="3. MIMO: decode latency를 늘리지 않는 다중 입출력에 대한 직접 링크" translate="no">​</a></h3>
<p>세 번째는 multi-input, multi-output(MIMO) 정식화다. 하나의 입력 스트림과 하나의 출력만 처리하는 대신 여러 입력·출력 관계를 묶어 표현력을 높인다. 논문 초록은 MIMO가 decode latency를 증가시키지 않으면서 모델 성능을 높이는 방향이라고 설명한다. 이 주장은 “계산이 전혀 늘지 않는다”는 뜻으로 읽기보다, 동일한 디코드 경로의 지연 예산 안에서 더 많은 정보를 활용하도록 설계했다는 의미로 읽는 편이 안전하다. 실제 비용은 상태 크기와 커널 구현을 포함해 본문에서 확인해야 한다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="초록에-명시된-결과">초록에 명시된 결과<a href="https://ql.gl/ko/blog/14e25d3e/#%EC%B4%88%EB%A1%9D%EC%97%90-%EB%AA%85%EC%8B%9C%EB%90%9C-%EA%B2%B0%EA%B3%BC" class="hash-link" aria-label="초록에 명시된 결과에 대한 직접 링크" title="초록에 명시된 결과에 대한 직접 링크" translate="no">​</a></h2>
<p>논문은 retrieval, state-tracking, downstream language modeling에서 개선을 보고한다. 1.5B 규모에서 Mamba-3는 다음으로 좋은 모델로 제시된 Gated DeltaNet보다 downstream 평균 정확도가 0.6 percentage points 높았고, MIMO 변형은 추가 1.2 points를 더해 총 1.8 points의 이득을 보였다고 초록에 적었다. 또 state-size 실험에서 Mamba-3는 이전 Mamba-2의 절반 상태 크기로도 비슷한 perplexity를 달성했다고 보고한다.</p>
<p>이 수치는 유용하지만 조건이 생략된 요약 수치다. 평균 정확도가 어떤 태스크 묶음인지, baseline의 학습 레시피와 토큰 수가 무엇인지, latency와 메모리의 실제 측정 조건이 무엇인지는 초록만으로 알 수 없다. 따라서 “1.8 points만큼 항상 우월하다”가 아니라 “논문이 명시한 평가 설정에서 그 차이를 보고했다”고 표현해야 한다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="논문의-논리-구조">논문의 논리 구조<a href="https://ql.gl/ko/blog/14e25d3e/#%EB%85%BC%EB%AC%B8%EC%9D%98-%EB%85%BC%EB%A6%AC-%EA%B5%AC%EC%A1%B0" class="hash-link" aria-label="논문의 논리 구조에 대한 직접 링크" title="논문의 논리 구조에 대한 직접 링크" translate="no">​</a></h2>
<p>공개 메타데이터와 초록은 문제 제기→선형 모델의 한계→세 가지 설계 개선→검색·상태 추적·언어 모델링 평가의 흐름을 따른다. 이는 IMRaD 전체를 확인한 분석이 아니라 초록에 드러난 논증 구조다. 방법론의 세 요소가 서로 다른 약점—표현력, 상태 추적, decode 효율—을 보완하도록 배치되어 있다는 점이 핵심이다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="시스템-관점의-함의">시스템 관점의 함의<a href="https://ql.gl/ko/blog/14e25d3e/#%EC%8B%9C%EC%8A%A4%ED%85%9C-%EA%B4%80%EC%A0%90%EC%9D%98-%ED%95%A8%EC%9D%98" class="hash-link" aria-label="시스템 관점의 함의에 대한 직접 링크" title="시스템 관점의 함의에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class=""><strong>추론 비용</strong>: 긴 시퀀스에서 고정 상태를 쓰는 구조는 KV cache와 다른 메모리 프로파일을 만들 수 있다. 하지만 GPU에서 유리한지는 상태 크기와 메모리 이동을 실측해야 한다.</li>
<li class=""><strong>평가</strong>: perplexity, retrieval, state tracking을 함께 봐야 한다. 평균 언어 모델 점수만으로는 “기억하는 방식”의 차이를 설명하기 어렵다.</li>
<li class=""><strong>배포</strong>: MIMO와 복소수 상태는 모델 파일의 수치 형식, 커널 지원, 양자화 전략에 영향을 줄 수 있다. 공개 초록에는 이 구현 세부가 없다.</li>
</ul>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="한계와-남은-질문">한계와 남은 질문<a href="https://ql.gl/ko/blog/14e25d3e/#%ED%95%9C%EA%B3%84%EC%99%80-%EB%82%A8%EC%9D%80-%EC%A7%88%EB%AC%B8" class="hash-link" aria-label="한계와 남은 질문에 대한 직접 링크" title="한계와 남은 질문에 대한 직접 링크" translate="no">​</a></h2>
<p>이 글의 정량 주장은 arXiv 초록에 명시된 범위에만 한정했다. 재현을 위해서는 논문의 실험 표, 모델·데이터 규모, 하드웨어, throughput과 peak memory 측정을 확인해야 한다. 또한 Mamba-2와의 perplexity 비교가 동일한 학습 조건인지, “절반 상태 크기”가 전체 메모리 절감으로 직결되는지는 알 수 없다. 실제 도입 전에는 긴 입력·배치 크기·동시 사용자 수별 decode benchmark와 장애 시 상태 초기화 동작까지 검증해야 한다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="sources">Sources<a href="https://ql.gl/ko/blog/14e25d3e/#sources" class="hash-link" aria-label="Sources에 대한 직접 링크" title="Sources에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class=""><a href="https://arxiv.org/abs/2603.15569" target="_blank" rel="noopener noreferrer" class="">Mamba-3: Improved Sequence Modeling using State Space Principles</a> — license: <code>unknown</code>, retrieved: <code>2026-08-19</code>, source type: <code>original</code></li>
<li class="">Image: Placeholder — original technical cover to be created — license: <code>placeholder-original</code></li>
</ul>]]></content>
        <author>
            <name>p4r4d0xb0x</name>
            <uri>https://bdev.io</uri>
        </author>
        <category label="AI" term="AI"/>
        <category label="Mamba" term="Mamba"/>
        <category label="State-Space Model" term="State-Space Model"/>
        <category label="Inference" term="Inference"/>
        <category label="Research" term="Research"/>
        <category label="Explainer" term="Explainer"/>
    </entry>
    <entry>
        <title type="html"><![CDATA[Hidden State Poisoning: Mamba의 효율적인 상태가 공격 표면이 될 때]]></title>
        <id>https://ql.gl/ko/blog/390c6aee/</id>
        <link href="https://ql.gl/ko/blog/390c6aee/"/>
        <updated>2026-08-19T00:00:00.000Z</updated>
        <summary type="html"><![CDATA[Hidden State Poisoning Attacks against Mamba-based Language Models는 짧은 트리거가 Mamba 계열의 은닉 상태를 덮어써 정보 검색을 무너뜨리는 현상을 분석한다. HiSPA와 RoBench-25를 중심으로, 효율적 상태와 보안 경계의 관계를 원문 초록 범위에서 설명한다.]]></summary>
        <content type="html"><![CDATA[<p>Mamba 계열의 매력은 긴 시퀀스를 고정 크기 상태로 처리하는 효율성이다. 그러나 이 압축 상태가 곧 보안 경계가 될 수 있다. <em>Hidden State Poisoning Attacks against Mamba-based Language Models</em>는 특정한 짧은 입력 구문이 모델의 은닉 상태를 부분적으로 덮어써, 이후 저장된 정보의 검색 능력을 무너뜨리는 현상인 Hidden State Poisoning Attack(HiSPA)을 연구한다. 이 글은 초록과 공개 메타데이터에 근거해 공격의 개념, 보고된 평가, 그리고 운영상 확인해야 할 질문을 정리한다.</p>
<p><img decoding="async" loading="lazy" src="https://ql.gl/img/blog/hidden-state-poisoning-mamba/cover.webp" alt="시퀀스가 Mamba 은닉 상태를 덮어쓰는 공격 경로 개념도" class="img_ev3q"></p>
<!-- -->
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="상태-압축이-만드는-비대칭">상태 압축이 만드는 비대칭<a href="https://ql.gl/ko/blog/390c6aee/#%EC%83%81%ED%83%9C-%EC%95%95%EC%B6%95%EC%9D%B4-%EB%A7%8C%EB%93%9C%EB%8A%94-%EB%B9%84%EB%8C%80%EC%B9%AD" class="hash-link" aria-label="상태 압축이 만드는 비대칭에 대한 직접 링크" title="상태 압축이 만드는 비대칭에 대한 직접 링크" translate="no">​</a></h2>
<p>Transformer는 이전 토큰을 KV cache에 비교적 직접적으로 남기고, 새 토큰이 attention으로 여러 위치를 참조한다. Mamba 같은 상태공간모델(SSM)은 입력을 순차적으로 처리하며 제한된 은닉 상태를 갱신한다. 이 방식은 메모리와 계산을 줄이는 대신, 과거 정보가 상태 업데이트를 거치며 섞인다는 특성을 만든다. 공격자는 이 업데이트 경로에 짧은 문구를 넣어, 정상적인 맥락에서 중요한 정보가 이후 출력에 도달하기 어렵게 만들 수 있다.</p>
<p>논문이 말하는 “partial amnesia”는 모델이 모든 것을 잊는다는 뜻이 아니다. 특정 공격 트리거 뒤에서 일부 정보 검색 능력이 붕괴하거나 약화되는 현상이다. 이 구분은 중요하다. 공격은 모델 파라미터를 바꾸는 학습 단계가 아니라, 입력 시퀀스에 삽입되는 짧은 구문으로 유도될 수 있기 때문이다. 따라서 입력 필터링, 문맥 격리, 상태 초기화, 검색 결과 검증이 모두 관련된 방어 층이 된다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 은닉 상태(hidden state)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 모델이 지금까지 읽은 내용을 다음 계산에 전달하기 위해 내부에 유지하는 숫자 묶음이다.</p><p>예시: 책을 읽으며 줄거리를 메모한 한 장의 노트다. 누군가 그 노트의 중요한 부분을 지우거나 다른 내용으로 바꾸면 다음 장면의 이해가 달라진다.</p></div></div>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 공격 트리거(trigger)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 특정한 동작이나 오류를 일으키도록 설계된 짧은 입력 패턴이다.</p><p>예시: 게임에서 특정 버튼 조합이 숨은 동작을 실행하는 것처럼, 문장 속 특정 구문이 모델의 상태 갱신에 영향을 준다.</p></div></div>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="hispa의-공격-모델">HiSPA의 공격 모델<a href="https://ql.gl/ko/blog/390c6aee/#hispa%EC%9D%98-%EA%B3%B5%EA%B2%A9-%EB%AA%A8%EB%8D%B8" class="hash-link" aria-label="HiSPA의 공격 모델에 대한 직접 링크" title="HiSPA의 공격 모델에 대한 직접 링크" translate="no">​</a></h2>
<p>초록은 HiSPA를 “특정 짧은 입력 구문이 은닉 상태를 비가역적으로 덮어써는 현상”으로 정의한다. 여기서 비가역적이라는 표현은 해당 순차 실행이 계속되는 동안 단순히 다음 정상 입력을 넣는 것만으로 원래 정보가 자동 복원되지 않을 수 있다는 의미로 해석할 수 있다. 다만 정확한 공격 생성 절차, 트리거 길이 분포, 공격자가 목표 정보와 모델 내부를 얼마나 알아야 하는지는 초록만으로 확인되지 않는다.</p>
<p>논문은 RoBench-25라는 벤치마크를 제안해 HiSPA가 적용된 상황에서 정보 검색 능력을 평가한다고 보고한다. 벤치마크의 존재는 공격을 단일 사례가 아니라 반복 측정 가능한 평가 문제로 만들려는 시도다. 보안 평가에서는 “트리거가 작동했는가”와 “정상 입력의 품질이 얼마나 유지되는가”를 분리해 봐야 한다. 그러나 구체적인 점수와 기준선은 본문 실험을 확인해야 한다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="보고된-결과의-의미">보고된 결과의 의미<a href="https://ql.gl/ko/blog/390c6aee/#%EB%B3%B4%EA%B3%A0%EB%90%9C-%EA%B2%B0%EA%B3%BC%EC%9D%98-%EC%9D%98%EB%AF%B8" class="hash-link" aria-label="보고된 결과의 의미에 대한 직접 링크" title="보고된 결과의 의미에 대한 직접 링크" translate="no">​</a></h2>
<p>초록에 따르면 RoBench-25에서 SSM의 취약성이 확인되었고, 52B 규모의 하이브리드 SSM–Transformer인 Jamba-1.7-Mini도 일부 HiSPA 트리거 아래에서 붕괴했다. 반면 순수 Transformer는 같은 비교에서 그러한 붕괴를 보이지 않았다고 보고한다. 또한 HiSPA 트리거는 Jamba를 Open-Prompt-Injections 벤치마크에서 크게 약화시켰지만, 순수 Transformer에는 같은 효과가 관찰되지 않았다고 한다.</p>
<p>이 결과를 “Transformer는 안전하다”로 확대하면 안 된다. 논문이 비교한 공격 유형과 모델 집합에 한정된 관찰이며, 다른 입력 공격·데이터 오염·도구 오용까지 배제하지 않는다. 오히려 핵심 메시지는 아키텍처별 상태 업데이트가 공격의 영향 범위를 바꿀 수 있다는 것이다. Mamba-2와 Mamba-2 기반 하이브리드인 Nemotron-3-Nano까지 이론·경험적 분석을 확장했다는 점도 초록에 명시되어 있다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="해석-가능성과-방어-방향">해석 가능성과 방어 방향<a href="https://ql.gl/ko/blog/390c6aee/#%ED%95%B4%EC%84%9D-%EA%B0%80%EB%8A%A5%EC%84%B1%EA%B3%BC-%EB%B0%A9%EC%96%B4-%EB%B0%A9%ED%96%A5" class="hash-link" aria-label="해석 가능성과 방어 방향에 대한 직접 링크" title="해석 가능성과 방어 방향에 대한 직접 링크" translate="no">​</a></h2>
<p>논문은 HiSPA 동안 Mamba의 은닉 계층에서 나타나는 패턴을 해석 가능성 연구로 분석하고, 이를 완화 시스템 구축에 사용할 수 있다고 제안한다. 이 방향은 상태를 직접 들여다보거나 이상 변화를 탐지해 입력을 차단하는 형태를 암시하지만, 실제 탐지기와 오탐률, 지연 비용, 어떤 계층을 검사하는지는 공개 초록에서 검증할 수 없다.</p>
<p>실무적으로는 다음 질문부터 시작해야 한다.</p>
<ul>
<li class="">외부 문서나 사용자 프롬프트가 모델의 지속 상태와 같은 실행 경로에 들어가는가?</li>
<li class="">요청별 상태를 격리하고, 신뢰 경계가 바뀔 때 상태를 초기화하는가?</li>
<li class="">검색 결과나 시스템 지시를 상태에 반영하기 전에 출처·권한·무결성을 확인하는가?</li>
<li class="">이상 트리거가 탐지되었을 때 fail-open인가 fail-closed인가?</li>
</ul>
<p>특히 에이전트 시스템에서는 상태 오염이 단순한 답변 오류가 아니라 도구 호출의 선택과 데이터 접근 범위에도 영향을 줄 수 있다. HiSPA 논문 초록은 도구 실행까지 직접 증명하지 않으므로, 이 부분은 보안 설계에 대한 합리적 확장 질문으로 남겨야 한다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="논문의-구조와-증거-경계">논문의 구조와 증거 경계<a href="https://ql.gl/ko/blog/390c6aee/#%EB%85%BC%EB%AC%B8%EC%9D%98-%EA%B5%AC%EC%A1%B0%EC%99%80-%EC%A6%9D%EA%B1%B0-%EA%B2%BD%EA%B3%84" class="hash-link" aria-label="논문의 구조와 증거 경계에 대한 직접 링크" title="논문의 구조와 증거 경계에 대한 직접 링크" translate="no">​</a></h2>
<p>공개 초록의 흐름은 SSM의 효율성과 미개척된 적대적 견고성 문제를 제시한 뒤, HiSPA 정의와 RoBench-25, 모델별 결과, 해석 가능성 기반 완화 방향으로 이어진다. 이는 문제→공격 정의→평가→방어 단서의 구조다. 하지만 이 글은 29페이지 원문 전체의 위협 모델과 부록을 재검증한 것이 아니므로, 공격 재현에 필요한 모든 조건을 제공하지 않는다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="한계와-운영상의-결론">한계와 운영상의 결론<a href="https://ql.gl/ko/blog/390c6aee/#%ED%95%9C%EA%B3%84%EC%99%80-%EC%9A%B4%EC%98%81%EC%83%81%EC%9D%98-%EA%B2%B0%EB%A1%A0" class="hash-link" aria-label="한계와 운영상의 결론에 대한 직접 링크" title="한계와 운영상의 결론에 대한 직접 링크" translate="no">​</a></h2>
<p>첫째, 초록에는 정확한 공격 성공률·정보 검색 점수·트리거 생성 비용이 없다. 둘째, Transformer가 해당 실험에서 무너지지 않았다는 사실은 모든 Transformer의 면역을 뜻하지 않는다. 셋째, “부분 기억상실”이 어떤 정보 유형과 문맥 길이에서 가장 심한지 추가 검증이 필요하다. 따라서 도입자는 아키텍처 선택만으로 보안을 판단하지 말고, 자신의 상태 관리·검색·도구 호출 파이프라인에 RoBench-25와 유사한 트리거 회귀 테스트를 추가해야 한다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="sources">Sources<a href="https://ql.gl/ko/blog/390c6aee/#sources" class="hash-link" aria-label="Sources에 대한 직접 링크" title="Sources에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class=""><a href="https://arxiv.org/abs/2601.01972" target="_blank" rel="noopener noreferrer" class="">Hidden State Poisoning Attacks against Mamba-based Language Models</a> — license: <code>unknown</code>, retrieved: <code>2026-08-19</code>, source type: <code>original</code></li>
<li class="">Image: Placeholder — original security diagram to be created — license: <code>placeholder-original</code></li>
</ul>]]></content>
        <author>
            <name>p4r4d0xb0x</name>
            <uri>https://bdev.io</uri>
        </author>
        <category label="AI" term="AI"/>
        <category label="Security" term="Security"/>
        <category label="Mamba" term="Mamba"/>
        <category label="Adversarial Robustness" term="Adversarial Robustness"/>
        <category label="Research" term="Research"/>
        <category label="Explainer" term="Explainer"/>
    </entry>
    <entry>
        <title type="html"><![CDATA[Resona: 선형 재귀 모델의 컨텍스트 복사를 검색으로 보완하기]]></title>
        <id>https://ql.gl/ko/blog/23360387/</id>
        <link href="https://ql.gl/ko/blog/23360387/"/>
        <updated>2026-08-19T00:00:00.000Z</updated>
        <summary type="html"><![CDATA[Resona는 입력 컨텍스트에서 필요한 정보를 검색해 선형 재귀 언어 모델에 다시 주입하는 프레임워크다. 논문 초록을 바탕으로 컨텍스트 복사의 병목, 검색 결합 방식의 의미, 그리고 실전 도입 전에 확인할 평가·비용·근거를 정리한다.]]></summary>
        <content type="html"><![CDATA[<p>선형 재귀 모델은 토큰을 읽으며 작은 상태를 갱신하므로, 긴 입력을 다루는 계산·메모리 비용에서 Transformer와 다른 선택지를 제공한다. 그러나 컨텍스트 안에 있는 특정 사실을 그대로 찾아 답해야 하는 상황에서는 약점이 드러난다. 모든 내용을 압축한 상태에서 “방금 앞에서 본 문자열을 정확히 복사하라”는 요구는 요약과 다른 문제이기 때문이다. Resona는 이 간극을 검색(retrieval)으로 메우려는 간단하고 확장 가능한 프레임워크를 제안한다.</p>
<p><img decoding="async" loading="lazy" src="https://ql.gl/img/blog/resona-context-copying/cover.webp" alt="입력 컨텍스트에서 관련 토큰을 검색해 선형 재귀 상태로 복사하는 Resona 개념도" class="img_ev3q"></p>
<!-- -->
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="컨텍스트를-요약하는-것과-복사하는-것은-다르다">컨텍스트를 요약하는 것과 복사하는 것은 다르다<a href="https://ql.gl/ko/blog/23360387/#%EC%BB%A8%ED%85%8D%EC%8A%A4%ED%8A%B8%EB%A5%BC-%EC%9A%94%EC%95%BD%ED%95%98%EB%8A%94-%EA%B2%83%EA%B3%BC-%EB%B3%B5%EC%82%AC%ED%95%98%EB%8A%94-%EA%B2%83%EC%9D%80-%EB%8B%A4%EB%A5%B4%EB%8B%A4" class="hash-link" aria-label="컨텍스트를 요약하는 것과 복사하는 것은 다르다에 대한 직접 링크" title="컨텍스트를 요약하는 것과 복사하는 것은 다르다에 대한 직접 링크" translate="no">​</a></h2>
<p>선형 재귀 모델은 각 시점의 입력과 이전 상태를 이용해 새 상태와 출력을 계산한다. 상태 크기가 입력 길이에 비례해 커지지 않는다는 점은 추론에 유리할 수 있다. 하지만 문맥의 모든 세부를 같은 정밀도로 보존할 수는 없다. 이름, 숫자, 임의 문자열처럼 “의미를 이해하는 것”보다 “원문을 정확히 회수하는 것”이 필요한 정보는 작은 상태에 압축하는 과정에서 사라질 수 있다.</p>
<p>Transformer는 attention으로 관련 위치를 직접 바라보는 능력이 강하다. 반대로 선형 재귀 모델은 과거 전체를 다시 조회하는 전용 경로가 없으면, 이미 압축된 상태에 의존해야 한다. Resona의 문제 정의는 이 구조적 차이를 인정하는 데서 시작한다. 모델을 Transformer처럼 만들겠다고 주장하기보다, 제공된 입력 컨텍스트 안에서 필요한 조각을 찾아 재귀 모델이 사용할 수 있도록 보조한다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 선형 재귀 모델(linear recurrent model)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 긴 문장을 읽으며 일정한 크기의 기억을 한 단계씩 업데이트하는 모델이다.</p><p>예시: 책 전체를 책상 위에 펼쳐두는 대신, 읽은 내용을 한 장의 요약 카드에 계속 적어 가며 다음 페이지를 읽는 방식이다.</p></div></div>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 검색(retrieval)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 지금 질문과 관련 있는 입력의 일부를 찾아 모델에 다시 제공하는 과정이다.</p><p>예시: 시험 문제를 보고 교과서 전체를 다시 읽지 않고, 색인에서 관련 페이지를 찾아 펼치는 것과 같다.</p></div></div>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="resona의-핵심-설계">Resona의 핵심 설계<a href="https://ql.gl/ko/blog/23360387/#resona%EC%9D%98-%ED%95%B5%EC%8B%AC-%EC%84%A4%EA%B3%84" class="hash-link" aria-label="Resona의 핵심 설계에 대한 직접 링크" title="Resona의 핵심 설계에 대한 직접 링크" translate="no">​</a></h2>
<p>논문 초록이 명시하는 핵심은 “제공된 입력 컨텍스트에서 검색한 정보를 통합하는 능력”을 선형 재귀 모델에 추가하는 것이다. 따라서 입력은 두 경로로 생각할 수 있다. 기본 경로는 토큰을 순차적으로 읽어 상태를 업데이트한다. 검색 경로는 현재 요구와 관련 있는 컨텍스트 조각을 찾아, 모델이 그 정보를 더 직접적으로 사용할 수 있게 한다. 두 경로를 어떻게 결합하는지의 정확한 레이어 위치, 검색 인덱스, 점수 함수, 학습 목적은 초록만으로 확정할 수 없다.</p>
<p>이 설계의 중요한 점은 retrieval이 외부 지식베이스에만 적용되는 기능이 아니라는 것이다. Resona의 초록은 “provided input context”에서 정보를 검색한다고 말한다. 즉 검색 대상은 문서나 대화에 이미 포함된 내용이다. 이 차이는 RAG의 일반적 이미지와 구분된다. 외부 문서를 새로 가져오는 시스템이 아니라, 현재 입력을 다시 주소 지정(address)하는 메커니즘에 가깝다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="왜-컨텍스트-복사에-도움이-되는가">왜 컨텍스트 복사에 도움이 되는가<a href="https://ql.gl/ko/blog/23360387/#%EC%99%9C-%EC%BB%A8%ED%85%8D%EC%8A%A4%ED%8A%B8-%EB%B3%B5%EC%82%AC%EC%97%90-%EB%8F%84%EC%9B%80%EC%9D%B4-%EB%90%98%EB%8A%94%EA%B0%80" class="hash-link" aria-label="왜 컨텍스트 복사에 도움이 되는가에 대한 직접 링크" title="왜 컨텍스트 복사에 도움이 되는가에 대한 직접 링크" translate="no">​</a></h2>
<p>컨텍스트 복사는 세 단계로 나눠 볼 수 있다. 첫째, 관련 위치를 찾는다. 둘째, 찾은 내용을 상태 또는 출력 경로에 연결한다. 셋째, 원문을 가능한 한 정확하게 생성한다. 순수 선형 재귀 모델은 첫 단계와 둘째 단계에서 압축 상태의 한계를 만날 수 있다. Resona는 검색을 통해 관련 위치를 다시 선택하게 함으로써, “모든 토큰을 같은 방식으로 기억해야 한다”는 부담을 줄인다.</p>
<p>이 방식은 다양한 task requirement에 맞춘 tailored behavior를 목표로 한다고 초록은 설명한다. 어떤 문제는 전체 흐름 이해가 필요하고, 어떤 문제는 한 줄의 식별자 복사가 필요하다. 검색 신호를 사용하면 모델은 과제에 따라 컨텍스트의 일부를 집중할 수 있다. 다만 검색이 정확하지 않으면 잘못된 조각을 복사하는 실패 모드가 생긴다. 따라서 성능이 올라간다는 주장과 함께 검색 recall, 잘못된 검색에 대한 강건성, 중복·상충 정보 처리도 평가해야 한다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="논문이-보고한-평가">논문이 보고한 평가<a href="https://ql.gl/ko/blog/23360387/#%EB%85%BC%EB%AC%B8%EC%9D%B4-%EB%B3%B4%EA%B3%A0%ED%95%9C-%ED%8F%89%EA%B0%80" class="hash-link" aria-label="논문이 보고한 평가에 대한 직접 링크" title="논문이 보고한 평가에 대한 직접 링크" translate="no">​</a></h2>
<p>Resona는 여러 선형 재귀 모델에 적용되었고, synthetic task와 real-world natural language task 모두에서 성능 향상을 관찰했다고 초록은 보고한다. 특히 개선 대상은 in-context learning과 language modeling 능력이다. 이 결과는 프레임워크가 특정 단일 모델의 트릭이 아니라 여러 선형 재귀 모델에 적용 가능한 일반 목적 방법일 가능성을 제시한다.</p>
<p>그러나 공개 초록에는 모델 목록, 데이터셋 이름, 절대 점수, 검색 비용, baseline 대비 개선 폭이 없다. 그러므로 “모든 재귀 모델에서 Transformer를 능가한다”거나 “검색만 붙이면 컨텍스트 문제가 해결된다”고 쓸 수 없다. 정확한 비교는 원문 실험 표와 구현을 확인해야 한다. 특히 synthetic copying benchmark의 성공이 실제 문서의 모순·소음·긴 지시문까지 보장하는지도 별도 질문이다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="시스템제품-관점의-함의">시스템·제품 관점의 함의<a href="https://ql.gl/ko/blog/23360387/#%EC%8B%9C%EC%8A%A4%ED%85%9C%EC%A0%9C%ED%92%88-%EA%B4%80%EC%A0%90%EC%9D%98-%ED%95%A8%EC%9D%98" class="hash-link" aria-label="시스템·제품 관점의 함의에 대한 직접 링크" title="시스템·제품 관점의 함의에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class=""><strong>메모리와 latency</strong>: 재귀 상태는 작더라도 검색 인덱스와 top-k 후보 관리가 추가된다. 전체 시스템 비용은 모델 계산만이 아니라 검색 자료구조와 메모리 이동을 포함해 측정해야 한다.</li>
<li class=""><strong>품질 관측</strong>: 답변만 평가하지 말고 어떤 컨텍스트 조각이 선택됐는지 기록해야 한다. 검색 근거가 틀리면 생성 모델의 오류인지 retrieval 오류인지 구분하기 어렵다.</li>
<li class=""><strong>보안 경계</strong>: 입력 컨텍스트에 악성 지시가 섞여 있다면 검색기가 그것을 관련 정보로 선택할 수 있다. 출처·권한·지시 우선순위를 검색 이전과 이후에 모두 검사해야 한다.</li>
<li class=""><strong>도입 전략</strong>: 긴 문서 전체를 무조건 재귀 상태에 넣기보다, 복사가 중요한 경로와 의미 요약이 중요한 경로를 분리해 A/B 평가하는 편이 합리적이다.</li>
</ul>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="논문의-구조-분석">논문의 구조 분석<a href="https://ql.gl/ko/blog/23360387/#%EB%85%BC%EB%AC%B8%EC%9D%98-%EA%B5%AC%EC%A1%B0-%EB%B6%84%EC%84%9D" class="hash-link" aria-label="논문의 구조 분석에 대한 직접 링크" title="논문의 구조 분석에 대한 직접 링크" translate="no">​</a></h2>
<p>초록에서 드러나는 논증은 선형 재귀 모델의 효율성→컨텍스트 회수 능력의 격차→Resona 프레임워크→여러 모델·합성 및 자연어 평가의 순서다. 이는 문제와 기여를 먼저 제시한 뒤 일반화 가능성을 평가하는 구조다. 다만 Methods, Results, Discussion의 실제 장 구성과 검색 모듈의 구체 구현은 원문 전체를 읽어야 확정할 수 있다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="한계와-남은-질문">한계와 남은 질문<a href="https://ql.gl/ko/blog/23360387/#%ED%95%9C%EA%B3%84%EC%99%80-%EB%82%A8%EC%9D%80-%EC%A7%88%EB%AC%B8" class="hash-link" aria-label="한계와 남은 질문에 대한 직접 링크" title="한계와 남은 질문에 대한 직접 링크" translate="no">​</a></h2>
<p>Resona의 검색은 입력에 이미 존재하는 정보를 더 잘 찾아 쓰는 데 초점이 있다. 입력에 사실이 없거나, 여러 출처가 충돌하거나, 최신 외부 지식이 필요한 문제는 별도 검색 시스템이 필요하다. 검색 결과가 상태에 결합되는 순간의 오류 전파와 개인정보 보존 정책도 검토해야 한다. 공개 초록에 정량 수치가 없으므로 이 글의 결론은 방향성 분석에 머문다. 실제 도입 전에는 원문 코드·실험 조건·메모리와 latency를 확인하고, 검색 실패·오염된 컨텍스트·상충 정보에 대한 회귀 테스트를 추가해야 한다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="sources">Sources<a href="https://ql.gl/ko/blog/23360387/#sources" class="hash-link" aria-label="Sources에 대한 직접 링크" title="Sources에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class=""><a href="https://arxiv.org/abs/2503.22913" target="_blank" rel="noopener noreferrer" class="">Resona: Improving Context Copying in Linear Recurrence Models with Retrieval</a> — license: <code>unknown</code>, retrieved: <code>2026-08-19</code>, source type: <code>original</code></li>
<li class="">Image: Placeholder — original technical cover to be created — license: <code>placeholder-original</code></li>
</ul>]]></content>
        <author>
            <name>p4r4d0xb0x</name>
            <uri>https://bdev.io</uri>
        </author>
        <category label="AI" term="AI"/>
        <category label="Retrieval" term="Retrieval"/>
        <category label="Recurrent Model" term="Recurrent Model"/>
        <category label="Language Model" term="Language Model"/>
        <category label="Research" term="Research"/>
        <category label="Explainer" term="Explainer"/>
    </entry>
    <entry>
        <title type="html"><![CDATA[고정 크기 hidden state는 메모리인가, 압축인가?]]></title>
        <id>https://ql.gl/ko/blog/ac4b2e1e/</id>
        <link href="https://ql.gl/ko/blog/ac4b2e1e/"/>
        <updated>2026-08-19T00:00:00.000Z</updated>
        <summary type="html"><![CDATA[고정 크기 recurrent hidden state를 기억 장치와 정보 압축의 관점에서 구분한다. S4, Mamba, RWKV, Resona를 중심으로 상태의 역할을 설명하고, Qdrant와 Statey는 외부 메모리 맥락으로 분리해 다룬다.]]></summary>
        <content type="html"><![CDATA[<p><img decoding="async" loading="lazy" src="https://ql.gl/img/blog/topic-hidden-state-memory/cover.webp" alt="cover placeholder" class="img_ev3q"></p>
<!-- -->
<p>recurrent 모델의 hidden state를 “메모리”라고 부르는 것은 편리하지만, 그대로 믿으면 중요한 차이를 놓친다. hidden state는 이전 입력을 다음 계산에 전달한다는 의미에서 메모리처럼 작동한다. 그러나 보통은 과거 토큰을 원본 형태로 보관하지 않는다. 고정된 차원 안에서 현재 목적에 유용하다고 학습된 통계와 흔적을 갱신한다. 따라서 더 엄밀한 표현은 <strong>목적 함수에 맞춘 압축 상태</strong>다.</p>
<p>이 구분은 단순한 말장난이 아니다. 어떤 정보를 정확히 복원해야 한다면 외부 저장소나 attention이 필요할 수 있고, 어떤 정보는 요약된 동역학만으로 충분할 수 있다. S4, Mamba, RWKV, Resona를 읽을 때도 “얼마나 많이 저장하는가”보다 “어떤 질의를 위해 어떤 상태 변환을 학습하는가”를 물어야 한다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="상태-메모리-압축의-세-가지-뜻">상태, 메모리, 압축의 세 가지 뜻<a href="https://ql.gl/ko/blog/ac4b2e1e/#%EC%83%81%ED%83%9C-%EB%A9%94%EB%AA%A8%EB%A6%AC-%EC%95%95%EC%B6%95%EC%9D%98-%EC%84%B8-%EA%B0%80%EC%A7%80-%EB%9C%BB" class="hash-link" aria-label="상태, 메모리, 압축의 세 가지 뜻에 대한 직접 링크" title="상태, 메모리, 압축의 세 가지 뜻에 대한 직접 링크" translate="no">​</a></h2>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: hidden state</div><div class="admonitionContent_BuS1"><p>시퀀스의 현재 위치에서 모델이 들고 있는 내부 표현이다. 다음 입력을 처리할 때 사용되며, recurrent 구조에서는 이전 state와 새 입력으로 갱신된다.</p></div></div>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 압축 표현</div><div class="admonitionContent_BuS1"><p>원래 데이터보다 적은 크기의 표현으로 바꾸되, 특정 작업에 필요한 정보는 최대한 보존하려는 표현이다. 무엇을 보존할지는 학습 목표가 결정한다.</p></div></div>
<p>일반적인 recurrent 업데이트를 단순화하면 <code>h_t = f(h_{t-1}, x_t)</code>로 쓸 수 있다. <code>h_t</code>의 차원이 시퀀스 길이에 따라 늘지 않는다면, 긴 입력을 일정한 크기의 병목으로 통과시키는 셈이다. 이 병목은 장점이면서 제약이다. 상태가 작으면 추론 메모리와 전송량이 예측 가능해지지만, 서로 다른 과거를 동일한 상태 근처로 보내는 충돌이 생길 수 있다. 이런 충돌을 정보 이론적으로 완전히 피할 수 있다는 보장은 없다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="s4-고정-상태가-단순한-요약만은-아닌-이유">S4: 고정 상태가 단순한 요약만은 아닌 이유<a href="https://ql.gl/ko/blog/ac4b2e1e/#s4-%EA%B3%A0%EC%A0%95-%EC%83%81%ED%83%9C%EA%B0%80-%EB%8B%A8%EC%88%9C%ED%95%9C-%EC%9A%94%EC%95%BD%EB%A7%8C%EC%9D%80-%EC%95%84%EB%8B%8C-%EC%9D%B4%EC%9C%A0" class="hash-link" aria-label="S4: 고정 상태가 단순한 요약만은 아닌 이유에 대한 직접 링크" title="S4: 고정 상태가 단순한 요약만은 아닌 이유에 대한 직접 링크" translate="no">​</a></h2>
<p>S4는 구조화된 상태공간 모델을 통해 긴 시퀀스를 효율적으로 모델링하려는 연구다. 논문은 연속시간 선형 시스템에서 출발해 장거리 의존성을 다루고, HiPPO 계열의 초기화와 구조화된 행렬을 활용해 계산 가능한 시퀀스 계층을 제안한다.</p>
<p><strong>출처가 말하는 것:</strong> S4는 긴 범위의 의존성을 모델링하는 SSM 계층과 효율적인 계산 구조를 제시하며, 여러 장문맥 벤치마크에서 강한 성능을 보고한다.</p>
<p><strong>해석:</strong> S4의 상태는 단순히 “최근 몇 토큰의 요약”으로만 이해하면 안 된다. 선형 동역학이 과거 입력의 여러 시간 척도에 반응하도록 설계될 수 있기 때문이다. 그래도 이것은 원문을 검색 가능한 형태로 저장하는 데이터베이스와 다르다. 상태는 특정한 연산 경로 안에서만 의미가 있으며, 임의의 문장을 그대로 꺼내 달라는 질의에 응답하도록 보장된 저장소가 아니다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="mamba-선택적으로-기억하고-선택적으로-버린다">Mamba: 선택적으로 기억하고 선택적으로 버린다<a href="https://ql.gl/ko/blog/ac4b2e1e/#mamba-%EC%84%A0%ED%83%9D%EC%A0%81%EC%9C%BC%EB%A1%9C-%EA%B8%B0%EC%96%B5%ED%95%98%EA%B3%A0-%EC%84%A0%ED%83%9D%EC%A0%81%EC%9C%BC%EB%A1%9C-%EB%B2%84%EB%A6%B0%EB%8B%A4" class="hash-link" aria-label="Mamba: 선택적으로 기억하고 선택적으로 버린다에 대한 직접 링크" title="Mamba: 선택적으로 기억하고 선택적으로 버린다에 대한 직접 링크" translate="no">​</a></h2>
<p>Mamba는 입력 의존적인 선택성을 SSM에 도입한다. 초록의 표현대로라면 모델은 입력 내용에 따라 정보를 전파하거나 잊는 정도를 조절한다. 이 점은 hidden state를 수동적인 압축 버퍼가 아니라, 학습된 쓰기·망각 정책을 가진 동적 필터로 만든다.</p>
<p>여기서 “기억한다”는 말은 데이터가 상태에 들어간다는 뜻과, 나중에 원하는 형태로 정확히 복원된다는 뜻을 분리해야 한다. Mamba가 특정 벤치마크에서 긴 의존성을 처리한다고 해서 모든 과거 토큰이 보존되는 것은 아니다. 벤치마크가 요구하는 함수에 유용한 특징이 남는 것이다. 이 차이가 recurrent state와 검색 메모리를 가르는 핵심이다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="rwkv-attention의-직관과-recurrent-실행의-결합">RWKV: attention의 직관과 recurrent 실행의 결합<a href="https://ql.gl/ko/blog/ac4b2e1e/#rwkv-attention%EC%9D%98-%EC%A7%81%EA%B4%80%EA%B3%BC-recurrent-%EC%8B%A4%ED%96%89%EC%9D%98-%EA%B2%B0%ED%95%A9" class="hash-link" aria-label="RWKV: attention의 직관과 recurrent 실행의 결합에 대한 직접 링크" title="RWKV: attention의 직관과 recurrent 실행의 결합에 대한 직접 링크" translate="no">​</a></h2>
<p>RWKV 계열은 attention과 유사한 가중 집계 직관을 유지하면서, recurrent 방식으로 실행할 수 있는 구조를 탐구한다. 공개된 RWKV 논문 설명은 병렬 학습과 효율적인 recurrent 추론을 함께 지향한다.</p>
<p><strong>출처와 해석:</strong> RWKV가 보여주는 것은 “recurrent state도 과거에 대한 가중 누적을 표현할 수 있다”는 설계 가능성이다. 하지만 누적 상태가 곧 무한한 기억은 아니다. 상태 차원과 업데이트 규칙이 정한 요약 공간 안에서, 모델이 다음 예측에 필요한 정보를 유지한다. 같은 상태에 여러 과거가 매핑될 수 있으므로, exact retrieval을 보장하는 메모리로 부르는 것은 과장이다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="resona-출처-확인이-필요한-확장-맥락">Resona: 출처 확인이 필요한 확장 맥락<a href="https://ql.gl/ko/blog/ac4b2e1e/#resona-%EC%B6%9C%EC%B2%98-%ED%99%95%EC%9D%B8%EC%9D%B4-%ED%95%84%EC%9A%94%ED%95%9C-%ED%99%95%EC%9E%A5-%EB%A7%A5%EB%9D%BD" class="hash-link" aria-label="Resona: 출처 확인이 필요한 확장 맥락에 대한 직접 링크" title="Resona: 출처 확인이 필요한 확장 맥락에 대한 직접 링크" translate="no">​</a></h2>
<p>Resona는 고정 상태·반복적 추론 또는 메모리 효율적 시퀀스 처리와 관련해 논의되는 연구 명칭으로 이 배치에서 함께 지정되었다. 그러나 현재 작성 환경에서 확인 가능한 증거는 논문의 정확한 arXiv 식별자와 전체 초록을 포함하지 않는다. 따라서 Resona에 대해 특정 성능 수치나 세부 메커니즘을 단정하지 않는다.</p>
<p>이 글에서 Resona가 제공하는 맥락은 **검증 대기(unverified)**로 표시한다. 이름만으로 “더 오래 기억한다”거나 “압축 손실을 해결했다”고 쓰는 것은 source-bounded 작성 원칙에 맞지 않는다. 정확한 논문 링크·초록·실험 조건을 확인한 뒤에만 주장을 확장해야 한다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="외부-메모리-맥락-qdrant와-statey는-다른-층이다">외부 메모리 맥락: Qdrant와 Statey는 다른 층이다<a href="https://ql.gl/ko/blog/ac4b2e1e/#%EC%99%B8%EB%B6%80-%EB%A9%94%EB%AA%A8%EB%A6%AC-%EB%A7%A5%EB%9D%BD-qdrant%EC%99%80-statey%EB%8A%94-%EB%8B%A4%EB%A5%B8-%EC%B8%B5%EC%9D%B4%EB%8B%A4" class="hash-link" aria-label="외부 메모리 맥락: Qdrant와 Statey는 다른 층이다에 대한 직접 링크" title="외부 메모리 맥락: Qdrant와 Statey는 다른 층이다에 대한 직접 링크" translate="no">​</a></h2>
<p>Qdrant는 벡터를 저장하고 유사도 검색을 제공하는 벡터 데이터베이스다. Statey는 기존 글에서 확인했듯이 채팅 안에서 구조화된 레코드를 읽고 쓰는 공유 데이터베이스라는 제품 설명을 제시한다. 둘 다 recurrent hidden state와 같은 종류의 “내부 상태”가 아니다.</p>
<p><strong>Qdrant/Statey에 대해 확인되는 맥락:</strong> 외부 저장소는 데이터를 세션·모델의 고정 차원 안에만 남겨 두지 않고, 나중에 검색하거나 구조화된 레코드로 다시 읽을 수 있게 한다. Qdrant는 임베딩 유사도 검색, Statey는 MCP 기반 레코드 공유라는 서로 다른 인터페이스를 강조한다.</p>
<p><strong>해석:</strong> 외부 메모리는 저장 용량과 재조회 가능성을 늘리는 대신, 쓰기 권한·검색 품질·지연시간·데이터 격리·삭제 정책을 운영해야 한다. 반대로 hidden state는 요청 처리 중 매우 빠르게 전달되지만, 세션이 끝나면 사라지거나 별도 저장 없이는 감사와 복구가 어렵다. “메모리”라는 단어를 둘 모두에 붙이더라도 신뢰 경계와 실패 방식은 다르다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="실무에서-무엇을-어디에-둘-것인가">실무에서 무엇을 어디에 둘 것인가<a href="https://ql.gl/ko/blog/ac4b2e1e/#%EC%8B%A4%EB%AC%B4%EC%97%90%EC%84%9C-%EB%AC%B4%EC%97%87%EC%9D%84-%EC%96%B4%EB%94%94%EC%97%90-%EB%91%98-%EA%B2%83%EC%9D%B8%EA%B0%80" class="hash-link" aria-label="실무에서 무엇을 어디에 둘 것인가에 대한 직접 링크" title="실무에서 무엇을 어디에 둘 것인가에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class=""><strong>hidden state:</strong> 최근 문맥의 요약, 연속적인 신호, 스트리밍 입력의 상태 추적처럼 매 토큰 업데이트가 필요한 정보.</li>
<li class=""><strong>검색 메모리:</strong> 나중에 원문 또는 근거를 재조회해야 하는 사실, 문서, 사용자 선호. 검색 키와 권한이 함께 설계되어야 한다.</li>
<li class=""><strong>구조화 레코드:</strong> 상태·소유자·변경 이력처럼 정확한 필드와 감사가 필요한 업무 데이터.</li>
</ul>
<p>이 분리는 모델 성능만의 문제가 아니다. hidden state는 압축 손실이 task loss에 반영되지만, 외부 메모리는 잘못된 쓰기나 오염된 검색 결과가 모델에 주입될 수 있다. 즉 압축은 표현상의 위험이고, 외부 메모리는 데이터 거버넌스상의 위험이다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="결론과-제한">결론과 제한<a href="https://ql.gl/ko/blog/ac4b2e1e/#%EA%B2%B0%EB%A1%A0%EA%B3%BC-%EC%A0%9C%ED%95%9C" class="hash-link" aria-label="결론과 제한에 대한 직접 링크" title="결론과 제한에 대한 직접 링크" translate="no">​</a></h2>
<p>고정 크기 hidden state는 메모리처럼 사용되지만, 본질적으로는 학습된 목적에 맞춘 압축 상태에 가깝다. S4는 장거리 동역학을, Mamba는 선택적 보존·망각을, RWKV는 recurrent 실행과 가중 집계의 결합을 보여준다. 이들은 모두 “과거를 일정한 표현으로 변환한다”는 공통점을 가지지만, exact storage나 임의 검색을 약속하지 않는다. Resona의 구체 주장은 식별자와 초록 확인 전까지 unverified다.</p>
<p>Qdrant와 Statey는 외부 메모리라는 별도 층의 사례다. 모델 내부 상태와 외부 저장소를 함께 사용할 때는 무엇이 요약이고 무엇이 원본인지, 누가 쓰고 읽는지, 삭제와 복구를 어떻게 하는지를 명시해야 한다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="sources">Sources<a href="https://ql.gl/ko/blog/ac4b2e1e/#sources" class="hash-link" aria-label="Sources에 대한 직접 링크" title="Sources에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class=""><a href="https://arxiv.org/abs/2111.00396" target="_blank" rel="noopener noreferrer" class="">S4: Structured State Space for Sequence Modeling</a> — abstract-level claims; retrieved: <code>2026-08-19</code>.</li>
<li class=""><a href="https://arxiv.org/abs/2312.00752" target="_blank" rel="noopener noreferrer" class="">Mamba: Linear-Time Sequence Modeling with Selective State Spaces</a> — abstract-level claims; retrieved: <code>2026-08-19</code>.</li>
<li class=""><a href="https://arxiv.org/abs/2305.13048" target="_blank" rel="noopener noreferrer" class="">RWKV: Reinventing RNNs for the Transformer Era</a> — abstract-level claims; retrieved: <code>2026-08-19</code>.</li>
<li class=""><a href="https://arxiv.org/search/?query=Resona&amp;searchtype=all" target="_blank" rel="noopener noreferrer" class="">Resona — arXiv search context</a> — exact paper identity and claims unverified at draft time.</li>
<li class=""><a href="https://qdrant.tech/" target="_blank" rel="noopener noreferrer" class="">Qdrant</a> — external vector-search context; retrieved: <code>2026-08-19</code>.</li>
<li class=""><a href="https://www.statey.ai/" target="_blank" rel="noopener noreferrer" class="">Statey</a> — external record/database context; retrieved: <code>2026-08-19</code>.</li>
<li class="">Image: cover placeholder; no final image asset is asserted.</li>
</ul>]]></content>
        <author>
            <name>p4r4d0xb0x</name>
            <uri>https://bdev.io</uri>
        </author>
        <category label="Research" term="Research"/>
        <category label="AI" term="AI"/>
        <category label="LLM" term="LLM"/>
        <category label="SSM" term="SSM"/>
        <category label="Memory" term="Memory"/>
        <category label="Explainer" term="Explainer"/>
    </entry>
    <entry>
        <title type="html"><![CDATA[Recurrent state는 새로운 공격 표면인가?]]></title>
        <id>https://ql.gl/ko/blog/9fb6baf2/</id>
        <link href="https://ql.gl/ko/blog/9fb6baf2/"/>
        <updated>2026-08-19T00:00:00.000Z</updated>
        <summary type="html"><![CDATA[Recurrent state와 에이전트 메모리를 보안 경계로 보는 관점. Mamba, Hidden State Poisoning, trajeckt, Valmis를 연결하되, 논문 증거와 제품·보안 맥락을 분리해 상태 오염·재사용·데이터 흐름 위험을 검토한다.]]></summary>
        <content type="html"><![CDATA[<p><img decoding="async" loading="lazy" src="https://ql.gl/img/blog/topic-recurrent-state-security/cover.webp" alt="cover placeholder" class="img_ev3q"></p>
<!-- -->
<p>Transformer 시스템에서 보안 논의는 프롬프트, 툴 인자, 검색 문서, 출력 필터를 중심으로 전개되어 왔다. recurrent 또는 SSM 계열을 운영하면 여기에 하나의 질문이 추가된다. 모델이 다음 입력으로 넘기는 hidden state를 누가 만들고, 얼마나 오래 유지하며, 어떤 경계를 넘어 재사용하는가?</p>
<p>이 질문은 “recurrent state가 곧 취약하다”는 뜻이 아니다. 상태가 있다는 사실만으로 공격이 성립하지는 않는다. 다만 상태가 세션 간에 유지되거나, 신뢰 수준이 다른 입력을 섞어 업데이트하거나, 도구 호출의 권한 판단에 영향을 준다면 새로운 보안 자산이자 공격 표면으로 취급해야 한다. 아래의 논문·프로젝트는 서로 다른 층을 다루므로 직접적인 동일시를 피한다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="상태-오염을-위협-모델로-바꾸기">상태 오염을 위협 모델로 바꾸기<a href="https://ql.gl/ko/blog/9fb6baf2/#%EC%83%81%ED%83%9C-%EC%98%A4%EC%97%BC%EC%9D%84-%EC%9C%84%ED%98%91-%EB%AA%A8%EB%8D%B8%EB%A1%9C-%EB%B0%94%EA%BE%B8%EA%B8%B0" class="hash-link" aria-label="상태 오염을 위협 모델로 바꾸기에 대한 직접 링크" title="상태 오염을 위협 모델로 바꾸기에 대한 직접 링크" translate="no">​</a></h2>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: state poisoning</div><div class="admonitionContent_BuS1"><p>공격자가 입력이나 저장된 기록을 통해 내부 상태에 악의적·오해를 부르는 정보를 심고, 이후 정상 입력에서 모델의 행동을 원하는 방향으로 유도하려는 위협이다.</p></div></div>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: provenance</div><div class="admonitionContent_BuS1"><p>데이터가 어디에서 왔고 어떤 변환을 거쳤는지 추적하는 정보다. 보안에서는 출처가 다른 데이터가 같은 권한으로 취급되지 않게 하는 데 중요하다.</p></div></div>
<p>일반적인 recurrent 업데이트를 <code>h_t = f(h_{t-1}, x_t)</code>라 하면 공격 가능 지점은 세 군데다. 첫째, 악의적인 <code>x_t</code>가 상태에 기록되는 순간. 둘째, 오염된 <code>h_t</code>가 다음 단계의 판단에 사용되는 순간. 셋째, 상태가 다른 사용자·세션·도구로 넘어가는 순간이다. 이 모델은 공격을 수식으로 증명하지 않지만, 설계 검토의 체크리스트를 제공한다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="mamba가-말하는-선택성과-보안상의-함의">Mamba가 말하는 선택성과 보안상의 함의<a href="https://ql.gl/ko/blog/9fb6baf2/#mamba%EA%B0%80-%EB%A7%90%ED%95%98%EB%8A%94-%EC%84%A0%ED%83%9D%EC%84%B1%EA%B3%BC-%EB%B3%B4%EC%95%88%EC%83%81%EC%9D%98-%ED%95%A8%EC%9D%98" class="hash-link" aria-label="Mamba가 말하는 선택성과 보안상의 함의에 대한 직접 링크" title="Mamba가 말하는 선택성과 보안상의 함의에 대한 직접 링크" translate="no">​</a></h2>
<p>Mamba는 입력에 따라 상태공간 파라미터를 선택적으로 조절해 정보를 선택적으로 전파·망각하는 selective SSM을 제안한다. 논문 초록의 주장은 효율적 시퀀스 모델링과 내용 의존적 상태 업데이트에 관한 것이지, 보안 메커니즘에 관한 것은 아니다.</p>
<p><strong>출처가 말하는 것:</strong> Mamba는 긴 시퀀스에서 선형 스케일링과 입력 선택성을 목표로 하며, 여러 작업에서 성능을 보고한다.</p>
<p><strong>보안적 해석:</strong> 선택적 업데이트는 유용한 정보와 공격자가 심은 정보를 구별하는 인증 장치가 아니다. 오히려 상태에 무엇을 남길지 결정하는 함수가 생겼다는 의미에서, 상태 업데이트를 감사·검증해야 할 이유가 커진다. 어떤 토큰이 상태를 크게 바꾸는지, 상태가 민감한 도구 호출을 제어하는지, 세션 경계에서 초기화되는지 확인해야 한다. Mamba 논문만으로 특정 poisoning 공격의 성공을 주장할 수는 없으며, 그 부분은 unverified다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="hidden-state-poisoning-직접-확인이-필요한-증거">Hidden State Poisoning: 직접 확인이 필요한 증거<a href="https://ql.gl/ko/blog/9fb6baf2/#hidden-state-poisoning-%EC%A7%81%EC%A0%91-%ED%99%95%EC%9D%B8%EC%9D%B4-%ED%95%84%EC%9A%94%ED%95%9C-%EC%A6%9D%EA%B1%B0" class="hash-link" aria-label="Hidden State Poisoning: 직접 확인이 필요한 증거에 대한 직접 링크" title="Hidden State Poisoning: 직접 확인이 필요한 증거에 대한 직접 링크" translate="no">​</a></h2>
<p>“Hidden State Poisoning”은 이 글의 위협 모델과 직접 맞닿은 지정 출처다. arXiv의 초록은 Mamba 계열 모델에서 짧은 트리거가 은닉 상태를 오염시켜 정보 검색을 약화시키는 HiSPA와 RoBench-25 평가를 보고한다. 다만 공격 절차, 성공률, 특정 모델의 취약성 범위 같은 세부는 원문 본문과 실험 절을 추가로 확인해야 하므로 이 글에서는 제한적으로 다룬다.</p>
<p>검증 가능한 범위 밖에서 안전하게 말할 수 있는 것은 개념적 질문뿐이다. 만약 외부 입력이 hidden state에 누적되고 이후의 의사결정에 영향을 준다면, 입력 필터만으로는 충분하지 않을 수 있다. 상태 자체를 신뢰하는 순간 공격자는 한 번의 입력이 아니라 이후 여러 단계에 영향을 미치는 지속성을 얻을 수 있기 때문이다. 이것은 논문 결과의 재현이 아니라, 제목이 지시하는 위협을 recurrent 시스템에 적용한 <strong>분석적 가설</strong>이다.</p>
<p>정확한 출처가 추가되면 확인해야 할 항목은 상태 접근 방식, 공격자가 관찰 가능한 출력, 상태 초기화 여부, 공격 지속 시간, 방어 실험의 기준선이다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="에이전트-보안-맥락-trajeckt는-상태를-어떻게-다루는가">에이전트 보안 맥락: trajeckt는 상태를 어떻게 다루는가<a href="https://ql.gl/ko/blog/9fb6baf2/#%EC%97%90%EC%9D%B4%EC%A0%84%ED%8A%B8-%EB%B3%B4%EC%95%88-%EB%A7%A5%EB%9D%BD-trajeckt%EB%8A%94-%EC%83%81%ED%83%9C%EB%A5%BC-%EC%96%B4%EB%96%BB%EA%B2%8C-%EB%8B%A4%EB%A3%A8%EB%8A%94%EA%B0%80" class="hash-link" aria-label="에이전트 보안 맥락: trajeckt는 상태를 어떻게 다루는가에 대한 직접 링크" title="에이전트 보안 맥락: trajeckt는 상태를 어떻게 다루는가에 대한 직접 링크" translate="no">​</a></h2>
<p>trajeckt는 에이전트의 각 도구 호출을 독립적으로 허용하는 대신, 사전에 봉인한 허용 궤적과 실행 중 데이터 흐름을 검사하는 게이트웨이로 설명된다. 저장소 문서의 예시는 데이터베이스 읽기→요약→외부 전송 같은 다단계 흐름에서 마지막 유출을 차단하는 방식이다.</p>
<p>이 설계는 recurrent hidden state 자체를 검사한다고 주장하지 않는다. 그러나 중요한 보안 원칙을 제공한다. 에이전트가 보고하는 현재 문맥이나 내부 계획만 믿지 않고, 에이전트 바깥에서 궤적과 provenance를 관리하는 것이다. recurrent state가 오염되더라도 도구 호출 권한과 데이터 싱크가 외부 정책으로 제한되어 있으면 피해 반경을 줄일 수 있다.</p>
<p><strong>제한:</strong> trajeckt 문서가 명시하듯 의미 기반 공격, 허용된 인과 경로 안에 숨은 공격, 기존 RBAC·인자 검증을 대체하는 문제는 남는다. 따라서 trajectory enforcement를 hidden-state 무결성 증명으로 해석해서는 안 된다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="valmis-격리와-프록시가-만드는-신뢰-경계">Valmis: 격리와 프록시가 만드는 신뢰 경계<a href="https://ql.gl/ko/blog/9fb6baf2/#valmis-%EA%B2%A9%EB%A6%AC%EC%99%80-%ED%94%84%EB%A1%9D%EC%8B%9C%EA%B0%80-%EB%A7%8C%EB%93%9C%EB%8A%94-%EC%8B%A0%EB%A2%B0-%EA%B2%BD%EA%B3%84" class="hash-link" aria-label="Valmis: 격리와 프록시가 만드는 신뢰 경계에 대한 직접 링크" title="Valmis: 격리와 프록시가 만드는 신뢰 경계에 대한 직접 링크" translate="no">​</a></h2>
<p>Valmis 저장소는 컨테이너 격리, 프록시를 통한 자격증명 보호, 에이전트 메모리·임베딩과 멀티스텝 워크플로우를 강조한다. 여기서 메모리는 recurrent hidden state가 아니라 pgvector와 임베딩을 사용하는 외부 메모리 층으로 설명된다.</p>
<p>이 차이는 보안상 중요하다. 외부 메모리는 검색·쓰기 권한, 데이터베이스 감사 로그, 테넌트 분리, 삭제 정책을 설계할 수 있다. 반면 런타임의 hidden state는 모델 계산 그래프 내부에 있어 같은 방식의 접근제어와 포렌식이 어렵다. Valmis의 프록시는 원시 자격증명을 에이전트가 직접 보지 않게 하지만, 프록시·호스트가 새로운 신뢰 중심이 된다는 한계도 기존 글에서 확인했다.</p>
<p><strong>출처와 해석의 경계:</strong> Valmis README는 보안 중심 아키텍처를 설명하지만 외부 보안 감사나 hidden-state poisoning 방어를 입증하지 않는다. 이 글은 제품 기능을 공격 방어의 증거로 과장하지 않는다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="새-공격-표면에-대한-운영-체크리스트">“새 공격 표면”에 대한 운영 체크리스트<a href="https://ql.gl/ko/blog/9fb6baf2/#%EC%83%88-%EA%B3%B5%EA%B2%A9-%ED%91%9C%EB%A9%B4%EC%97%90-%EB%8C%80%ED%95%9C-%EC%9A%B4%EC%98%81-%EC%B2%B4%ED%81%AC%EB%A6%AC%EC%8A%A4%ED%8A%B8" class="hash-link" aria-label="“새 공격 표면”에 대한 운영 체크리스트에 대한 직접 링크" title="“새 공격 표면”에 대한 운영 체크리스트에 대한 직접 링크" translate="no">​</a></h2>
<ol>
<li class=""><strong>수명:</strong> 상태가 요청·사용자·테넌트 사이에서 재사용되는가? 기본값은 세션 경계에서 초기화하는 쪽이 안전하다.</li>
<li class=""><strong>출처:</strong> 신뢰된 시스템 이벤트와 사용자 텍스트가 같은 업데이트 경로로 들어가는가? provenance를 별도로 기록해야 한다.</li>
<li class=""><strong>권한:</strong> 상태가 툴 선택, 외부 쓰기, 자격증명 사용을 직접 결정하는가? 그렇다면 상태만으로 승인하지 말고 외부 정책을 둔다.</li>
<li class=""><strong>관찰성:</strong> 상태 변화의 크기·원인·시점을 기록할 수 있는가? 원본 state를 그대로 로그에 남기면 민감 정보가 새로 유출될 수 있으므로 해시·통계·샘플링을 검토한다.</li>
<li class=""><strong>복구:</strong> 오염 의심 시 상태를 폐기하고 검증된 체크포인트에서 재생성할 수 있는가?</li>
<li class=""><strong>외부 메모리와 분리:</strong> 검색 DB의 기록과 ephemeral hidden state를 같은 신뢰도로 취급하지 않는가?</li>
</ol>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="결론과-제한">결론과 제한<a href="https://ql.gl/ko/blog/9fb6baf2/#%EA%B2%B0%EB%A1%A0%EA%B3%BC-%EC%A0%9C%ED%95%9C" class="hash-link" aria-label="결론과 제한에 대한 직접 링크" title="결론과 제한에 대한 직접 링크" translate="no">​</a></h2>
<p>Recurrent state는 자동으로 취약점이 되는 것이 아니지만, 지속성·불투명성·권한 영향이라는 세 조건을 가질 때 새로운 공격 표면으로 모델링할 이유가 충분하다. Mamba는 선택적 상태 업데이트라는 기술적 가능성을 보여주지만 보안 보장은 제공하지 않는다. Hidden State Poisoning은 직접적인 위협 가설을 가리키지만, 이 초안에서 정확한 서지와 실험은 검증되지 않았다. trajeckt는 에이전트 바깥의 궤적·데이터 흐름 통제로 피해를 제한하는 맥락을, Valmis는 컨테이너·프록시·외부 메모리의 신뢰 경계를 보여준다.</p>
<p>따라서 실무 결론은 상태를 무조건 암호화하라는 단순한 처방이 아니다. 상태의 수명과 출처를 분리하고, 민감한 행동은 외부 정책으로 재검증하며, 오염 시 폐기·복구 가능한 구조를 갖추라는 것이다. 특히 이 글에 포함된 Hidden State Poisoning의 공격 세부, 모델별 재현성, Valmis의 실제 운영 보안성은 추가 원문·코드 검토 전까지 unverified로 남긴다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="sources">Sources<a href="https://ql.gl/ko/blog/9fb6baf2/#sources" class="hash-link" aria-label="Sources에 대한 직접 링크" title="Sources에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class=""><a href="https://arxiv.org/abs/2312.00752" target="_blank" rel="noopener noreferrer" class="">Mamba: Linear-Time Sequence Modeling with Selective State Spaces</a> — abstract-level claims; retrieved: <code>2026-08-19</code>.</li>
<li class=""><a href="https://arxiv.org/search/?query=Hidden+State+Poisoning&amp;searchtype=all" target="_blank" rel="noopener noreferrer" class="">Hidden State Poisoning — arXiv search context</a> — exact paper identity, attack details, and evaluation unverified at draft time.</li>
<li class=""><a href="https://github.com/beebeeVB/trajeckt/" target="_blank" rel="noopener noreferrer" class="">beebeeVB/trajeckt</a> — repository README/documentation context; retrieved: <code>2026-08-19</code>.</li>
<li class=""><a href="https://github.com/valmishq/valmis" target="_blank" rel="noopener noreferrer" class="">valmishq/valmis</a> — repository README context; retrieved: <code>2026-08-19</code>.</li>
<li class="">Agent memory security context: external memory poisoning/provenance concerns are analysis context, not a claim of a single identified paper; exact source set unverified.</li>
<li class="">Image: cover placeholder; no final image asset is asserted.</li>
</ul>]]></content>
        <author>
            <name>p4r4d0xb0x</name>
            <uri>https://bdev.io</uri>
        </author>
        <category label="Research" term="Research"/>
        <category label="Security" term="Security"/>
        <category label="AI" term="AI"/>
        <category label="LLM" term="LLM"/>
        <category label="Recurrent" term="Recurrent"/>
        <category label="Agents" term="Agents"/>
        <category label="Explainer" term="Explainer"/>
    </entry>
    <entry>
        <title type="html"><![CDATA[SSM은 Transformer를 대체하는가, 아니면 역할을 나누는가?]]></title>
        <id>https://ql.gl/ko/blog/a7c32433/</id>
        <link href="https://ql.gl/ko/blog/a7c32433/"/>
        <updated>2026-08-19T00:00:00.000Z</updated>
        <summary type="html"><![CDATA[상태공간 모델과 Transformer의 경쟁을 구조적 대체가 아닌 역할 분담의 문제로 읽는다. Mamba, Griffin, Jamba, Mamba-3의 초록과 공개된 주장에 근거해 긴 문맥·생성·하드웨어 효율성의 트레이드오프를 정리한다.]]></summary>
        <content type="html"><![CDATA[<p><img decoding="async" loading="lazy" src="https://ql.gl/img/blog/topic-ssm-transformer-or-hybrid/cover.webp" alt="cover placeholder" class="img_ev3q"></p>
<!-- -->
<p>Transformer 이후의 시퀀스 모델 논쟁은 자주 왕좌 교체의 언어로 번역된다. “다음은 SSM인가?”, “attention은 끝났는가?”라는 질문은 이해하기 쉽지만, 실제 시스템 설계에는 충분하지 않다. 더 정확한 질문은 어떤 계산을 어느 층에 맡길 것인가이다. 긴 입력을 한 번에 처리해야 하는가, 토큰을 하나씩 생성해야 하는가, 과거의 모든 토큰을 다시 참조해야 하는가, 아니면 고정 크기 상태만 업데이트하면 되는가에 따라 좋은 구조가 달라진다.</p>
<p>이 글의 결론부터 말하면, 공개된 초록 수준의 증거만으로 SSM이 Transformer를 전면 대체한다고 말하기는 어렵다. 반면 SSM이 Transformer의 비용이 커지는 구간에서 독립적인 선택지이거나, 두 구조를 함께 쓰는 하이브리드의 구성 요소라는 해석은 여러 연구의 방향과 잘 맞는다. 아래에서 출처의 주장과 이 글의 해석을 분리해 보자.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="먼저-구분할-것-attention과-state">먼저 구분할 것: attention과 state<a href="https://ql.gl/ko/blog/a7c32433/#%EB%A8%BC%EC%A0%80-%EA%B5%AC%EB%B6%84%ED%95%A0-%EA%B2%83-attention%EA%B3%BC-state" class="hash-link" aria-label="먼저 구분할 것: attention과 state에 대한 직접 링크" title="먼저 구분할 것: attention과 state에 대한 직접 링크" translate="no">​</a></h2>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 상태공간 모델(SSM)</div><div class="admonitionContent_BuS1"><p>SSM은 입력을 읽으면서 내부 상태를 갱신하고, 그 상태에서 출력을 만드는 계열이다. 긴 시퀀스를 고정 크기 또는 제한된 크기의 동적 상태로 요약한다는 점이 핵심 직관이다.</p><p>일상 예: 긴 회의에서 모든 발언 녹취를 책상 위에 펼쳐 두는 대신, 회의 진행자가 현재까지의 핵심을 메모 한 장에 계속 갱신하는 방식과 비슷하다.</p></div></div>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: self-attention</div><div class="admonitionContent_BuS1"><p>각 토큰이 다른 토큰을 얼마나 참고할지 계산하는 메커니즘이다. 과거 토큰을 직접 다시 볼 수 있다는 것이 강점인 동시에, 긴 문맥에서는 계산·메모리 비용의 원인이 된다.</p></div></div>
<p>Transformer의 attention은 직접적인 토큰 간 접근을 제공한다. 이 특성은 문맥 안에서 멀리 떨어진 두 단어의 관계를 선택적으로 확인하는 데 유리하다. 그러나 자동회귀 생성에서는 과거의 key/value를 캐시해야 하며, 컨텍스트가 길어질수록 캐시와 대역폭이 중요한 비용이 된다. SSM 계열은 이와 다른 경로를 택한다. 매 단계에서 상태를 갱신하고, 다음 계산에 필요한 정보를 상태에 남긴다. 이때 과거를 그대로 보존하는 것이 아니라 모델이 학습한 동역학으로 변환한다.</p>
<p>이 차이는 “SSM은 기억력이 좋고 attention은 나쁘다”라는 성격 비교가 아니다. 어떤 정보를 원본에 가깝게 재조회해야 하는지, 어떤 정보는 요약해도 되는지가 문제다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="mamba-대체제라기보다-계산-경로의-재설계">Mamba: 대체제라기보다 계산 경로의 재설계<a href="https://ql.gl/ko/blog/a7c32433/#mamba-%EB%8C%80%EC%B2%B4%EC%A0%9C%EB%9D%BC%EA%B8%B0%EB%B3%B4%EB%8B%A4-%EA%B3%84%EC%82%B0-%EA%B2%BD%EB%A1%9C%EC%9D%98-%EC%9E%AC%EC%84%A4%EA%B3%84" class="hash-link" aria-label="Mamba: 대체제라기보다 계산 경로의 재설계에 대한 직접 링크" title="Mamba: 대체제라기보다 계산 경로의 재설계에 대한 직접 링크" translate="no">​</a></h2>
<p>Mamba 논문은 selective state space model을 제안하면서, 입력에 따라 상태공간 파라미터를 선택적으로 조절하는 구조를 제시한다. 초록에서 저자들은 선택성이 SSM이 입력 내용에 맞춰 정보를 기억하거나 잊게 하며, 긴 시퀀스에서 선형 스케일링과 빠른 추론을 목표로 한다고 설명한다. 이는 고정된 선형 필터가 모든 토큰을 같은 방식으로 처리하는 그림과 다르다.</p>
<p><strong>출처가 말하는 것:</strong> Mamba는 selective SSM과 하드웨어 인식 알고리즘을 결합하고, 언어·오디오·유전체 등 여러 모달리티에서 선형 시퀀스 길이 스케일링을 보고한다. Transformer와의 비교 실험도 있지만, 초록만으로 모든 규모·데이터·하드웨어에서의 우월성을 일반화할 수는 없다.</p>
<p><strong>해석:</strong> Mamba의 의미는 attention을 폐기했다는 데 있기보다, 토큰별 직접 참조가 필요하지 않은 계산을 상태 업데이트로 바꿀 수 있음을 보여준 데 있다. 스트리밍 입력, 긴 문맥의 전처리, 반복적인 패턴 추적처럼 “현재까지의 요약 상태”가 유효한 작업에서는 이 경로가 매력적이다. 반대로 정확한 원문 재인용이나 임의 토큰 간 조합이 핵심인 작업은 여전히 직접 접근 구조의 이점을 가질 수 있다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="griffin-recurrent와-local-attention의-절충">Griffin: recurrent와 local attention의 절충<a href="https://ql.gl/ko/blog/a7c32433/#griffin-recurrent%EC%99%80-local-attention%EC%9D%98-%EC%A0%88%EC%B6%A9" class="hash-link" aria-label="Griffin: recurrent와 local attention의 절충에 대한 직접 링크" title="Griffin: recurrent와 local attention의 절충에 대한 직접 링크" translate="no">​</a></h2>
<p>Google의 Griffin은 gated linear recurrences와 local attention을 결합한 hybrid 모델 계열로 제안되었다. 이 조합 자체가 중요한 신호다. 연구 질문이 “attention 또는 recurrence 중 하나를 고르라”가 아니라, 선형 recurrence가 잘하는 장거리 요약과 local attention이 잘하는 근거리 상호작용을 한 모델 안에서 배치하는 방향이기 때문이다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: local attention</div><div class="admonitionContent_BuS1"><p>전체 문맥이 아니라 최근의 제한된 창(window)에 대해서만 attention을 계산하는 방식이다. 가까운 토큰의 정밀한 관계는 유지하면서 전체 비용을 줄이려는 절충이다.</p></div></div>
<p><strong>출처와 해석의 경계:</strong> Griffin의 초록은 이 하이브리드 구조가 언어 모델링과 장문맥 평가에서 경쟁력 있는 특성을 보인다고 보고한다. 그러나 이것이 모든 Transformer 블록을 recurrence로 교체해야 한다는 처방은 아니다. 오히려 서로 다른 시간 범위의 상호작용을 다른 연산에 맡기는 설계 공간을 열었다고 읽는 편이 안전하다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="jamba-하이브리드는-연구-아이디어에서-시스템-구성으로">Jamba: 하이브리드는 연구 아이디어에서 시스템 구성으로<a href="https://ql.gl/ko/blog/a7c32433/#jamba-%ED%95%98%EC%9D%B4%EB%B8%8C%EB%A6%AC%EB%93%9C%EB%8A%94-%EC%97%B0%EA%B5%AC-%EC%95%84%EC%9D%B4%EB%94%94%EC%96%B4%EC%97%90%EC%84%9C-%EC%8B%9C%EC%8A%A4%ED%85%9C-%EA%B5%AC%EC%84%B1%EC%9C%BC%EB%A1%9C" class="hash-link" aria-label="Jamba: 하이브리드는 연구 아이디어에서 시스템 구성으로에 대한 직접 링크" title="Jamba: 하이브리드는 연구 아이디어에서 시스템 구성으로에 대한 직접 링크" translate="no">​</a></h2>
<p>Jamba는 Transformer와 Mamba 계열 층을 결합한 언어 모델 아키텍처로 공개되었다. 공개된 설명에서 핵심은 attention과 Mamba 층의 혼합, 그리고 MoE를 통한 모델 용량·추론 비용 조절이다. 이 사례는 역할 분담이 단순한 이론적 비유가 아니라 실제 모델 구성의 선택이 될 수 있음을 보여준다.</p>
<p>Jamba에서 attention은 모든 정보를 직접 보아야 하는 구간을 담당하고, Mamba 층은 긴 시퀀스를 선형적인 상태 경로로 처리하는 부분을 맡는 식으로 해석할 수 있다. 다만 어느 층의 비율이 최적이며, 각 태스크에서 병목이 정확히 어떻게 이동하는지는 모델 크기와 구현에 의존한다. 논문·제품 페이지의 결과를 다른 배포 환경의 보장으로 읽어서는 안 된다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="mamba-3가-던지는-질문-이론적-선형성만으로-충분한가">Mamba-3가 던지는 질문: 이론적 선형성만으로 충분한가<a href="https://ql.gl/ko/blog/a7c32433/#mamba-3%EA%B0%80-%EB%8D%98%EC%A7%80%EB%8A%94-%EC%A7%88%EB%AC%B8-%EC%9D%B4%EB%A1%A0%EC%A0%81-%EC%84%A0%ED%98%95%EC%84%B1%EB%A7%8C%EC%9C%BC%EB%A1%9C-%EC%B6%A9%EB%B6%84%ED%95%9C%EA%B0%80" class="hash-link" aria-label="Mamba-3가 던지는 질문: 이론적 선형성만으로 충분한가에 대한 직접 링크" title="Mamba-3가 던지는 질문: 이론적 선형성만으로 충분한가에 대한 직접 링크" translate="no">​</a></h2>
<p>Mamba-3는 상태공간 원리로 시퀀스 모델링을 개선하며 지수-사다리꼴 이산화, 복소수 상태 업데이트, MIMO SSM을 제안한다. 제공된 논문 요약은 MIMO가 메모리 병목 상황에서 디코딩 FLOP을 늘려 하드웨어 이용률을 높이려는 설계라고 설명한다. 즉 “선형 복잡도”라는 표기만으로 실제 지연시간이 결정되지 않는다는 점을 강조한다.</p>
<p><strong>출처가 보고한 수치:</strong> 증거 팩 요약에는 1.5B 규모에서 기본 Mamba-3가 강한 선형 계층 대비 평균 0.6%p, MIMO가 추가 약 1.2%p의 다운스트림 향상을 보였고, 동일 상태 크기에서 Mamba-2 대비 디코딩 FLOP을 최대 4배 늘리면서 유사한 실제 지연시간을 보고했다고 적혀 있다.</p>
<p><strong>제한:</strong> 이 수치는 특정 실험 조건의 결과다. 하드웨어 모델, 커널 버전, 배치 크기, 정확한 평가 목록을 확인하지 않고 “SSM이 항상 더 빠르다”고 결론내릴 수 없다. Mamba-3는 SSM 내부의 설계 여지도 여전히 크다는 증거이지, Transformer의 보편적 폐기를 입증하는 증거는 아니다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="그래서-역할을-어떻게-나눌-것인가">그래서 역할을 어떻게 나눌 것인가<a href="https://ql.gl/ko/blog/a7c32433/#%EA%B7%B8%EB%9E%98%EC%84%9C-%EC%97%AD%ED%95%A0%EC%9D%84-%EC%96%B4%EB%96%BB%EA%B2%8C-%EB%82%98%EB%88%8C-%EA%B2%83%EC%9D%B8%EA%B0%80" class="hash-link" aria-label="그래서 역할을 어떻게 나눌 것인가에 대한 직접 링크" title="그래서 역할을 어떻게 나눌 것인가에 대한 직접 링크" translate="no">​</a></h2>
<p>실무적으로는 세 가지 배치가 가능하다.</p>
<ol>
<li class=""><strong>SSM 중심:</strong> 입력이 매우 길고, 스트리밍 또는 저메모리 추론이 중요하며, 과거의 충분한 표현이 요약 상태로 유지될 수 있을 때 검토한다.</li>
<li class=""><strong>attention 중심:</strong> 임의의 과거 토큰을 정밀하게 재참조하거나, 문맥 안의 희소한 관계를 직접 조합하는 능력이 우선일 때 검토한다.</li>
<li class=""><strong>하이브리드:</strong> 가까운 관계는 local attention, 장거리 누적은 recurrent/SSM, 특정 층의 전역 참조는 attention에 맡긴다. Jamba와 Griffin은 이 방향의 구체적 사례다.</li>
</ol>
<p>이 선택은 모델 구조만의 문제가 아니다. 학습 병렬화, KV 캐시, 커널 지원, 배치 처리, 품질 평가, 장애 시 상태 복구까지 함께 평가해야 한다. SSM은 상태를 가진다. 따라서 요청 간 상태를 어떻게 격리하고 저장할지도 Transformer와 다른 운영 질문이 된다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="결론과-한계">결론과 한계<a href="https://ql.gl/ko/blog/a7c32433/#%EA%B2%B0%EB%A1%A0%EA%B3%BC-%ED%95%9C%EA%B3%84" class="hash-link" aria-label="결론과 한계에 대한 직접 링크" title="결론과 한계에 대한 직접 링크" translate="no">​</a></h2>
<p>SSM은 Transformer의 “후계자”라기보다, 시퀀스 계산을 분해하는 또 하나의 축에 가깝다. Mamba는 선택적 상태 경로를, Griffin은 recurrence와 local attention의 조합을, Jamba는 hybrid 언어 모델을, Mamba-3는 SSM의 품질·하드웨어 개선 가능성을 보여준다. 이 증거들이 함께 지지하는 보수적인 결론은 “단일 승자”가 아니라 workload에 따른 역할 분담이다.</p>
<p>다만 이 글은 각 논문의 초록과 공개 요약에 한정했다. 전체 실험표, 구현별 메모리 사용량, 상용 모델의 비공개 최적화, 태스크별 실패 사례는 검증하지 못했으며 unverified로 남긴다. 실제 도입 전에는 동일한 데이터·하드웨어·배치 조건에서 attention-only, SSM-only, hybrid를 직접 비교해야 한다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="sources">Sources<a href="https://ql.gl/ko/blog/a7c32433/#sources" class="hash-link" aria-label="Sources에 대한 직접 링크" title="Sources에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class=""><a href="https://arxiv.org/abs/2312.00752" target="_blank" rel="noopener noreferrer" class="">Mamba: Linear-Time Sequence Modeling with Selective State Spaces</a> — abstract-level claims; retrieved: <code>2026-08-19</code>.</li>
<li class=""><a href="https://arxiv.org/abs/2402.19427" target="_blank" rel="noopener noreferrer" class="">Griffin: Mixing Gated Linear Recurrences with Local Attention for Efficient Language Models</a> — abstract-level claims; retrieved: <code>2026-08-19</code>.</li>
<li class=""><a href="https://arxiv.org/abs/2403.19887" target="_blank" rel="noopener noreferrer" class="">Jamba: A Hybrid Transformer-Mamba Language Model</a> — abstract-level claims; retrieved: <code>2026-08-19</code>.</li>
<li class=""><a href="https://arxiv.org/abs/2603.15569" target="_blank" rel="noopener noreferrer" class="">Mamba-3: Improved Sequence Modeling Using State Space Principles</a> — paper summary/evidence pack; retrieved: <code>2026-08-19</code>.</li>
<li class="">Image: cover placeholder; no final image asset is asserted.</li>
</ul>]]></content>
        <author>
            <name>p4r4d0xb0x</name>
            <uri>https://bdev.io</uri>
        </author>
        <category label="Research" term="Research"/>
        <category label="AI" term="AI"/>
        <category label="LLM" term="LLM"/>
        <category label="SSM" term="SSM"/>
        <category label="Transformer" term="Transformer"/>
        <category label="Explainer" term="Explainer"/>
    </entry>
    <entry>
        <title type="html"><![CDATA[Surrogate Gradient를 이해하기 위한 논문 지도]]></title>
        <id>https://ql.gl/ko/blog/d657d100/</id>
        <link href="https://ql.gl/ko/blog/d657d100/"/>
        <updated>2026-07-13T00:00:00.000Z</updated>
        <summary type="html"><![CDATA[스파이킹 신경망의 불연속 스파이크를 역전파로 학습시키는 Surrogate Gradient를 이해하기 위해, SNN 모델링·역전파·STDP·SpikeProp·ANN-to-SNN·SuperSpike·SLAYER·STBP 논문을 읽는 순서로 정리한다.]]></summary>
        <content type="html"><![CDATA[<p>Surrogate Gradient는 스파이킹 신경망, 즉 SNN을 현대 딥러닝의 학습 도구와 연결하는 우회로다. 순전파에서는 실제 스파이크를 쓰고, 역전파에서는 미분 가능한 가짜 기울기를 쓴다. 한 문장으로는 간단하지만, 이 아이디어를 제대로 이해하려면 세 가지 배경이 필요하다.</p>
<p>첫째, 스파이크 뉴런은 왜 불연속 동역학인가. 둘째, 역전파는 왜 미분 가능성을 요구하는가. 셋째, SNN은 Surrogate Gradient 이전에 어떤 방식으로 학습됐고 무엇이 막혔는가.</p>
<!-- -->
<p><img decoding="async" loading="lazy" alt="Dark glass terminal roadmap from spiking neuron models to backpropagation and surrogate gradients" src="data:image/svg+xml;base64,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" width="1200" height="630" class="img_ev3q"></p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="먼저-읽을-목표-논문">먼저 읽을 목표 논문<a href="https://ql.gl/ko/blog/d657d100/#%EB%A8%BC%EC%A0%80-%EC%9D%BD%EC%9D%84-%EB%AA%A9%ED%91%9C-%EB%85%BC%EB%AC%B8" class="hash-link" aria-label="먼저 읽을 목표 논문에 대한 직접 링크" title="먼저 읽을 목표 논문에 대한 직접 링크" translate="no">​</a></h2>
<p>목표 논문은 Neftci, Mostafa, Zenke의 <em>Surrogate Gradient Learning in Spiking Neural Networks</em>다. 이 글은 “새로운 단일 알고리즘 제안”이라기보다 SNN 학습이 마주치는 문제를 단계적으로 풀어 설명하는 리뷰에 가깝다. arXiv 초록도 같은 점을 강조한다. SNN은 binary하고 dynamical하기 때문에 학습이 어렵고, Surrogate Gradient는 이 문제를 유연하고 효율적으로 우회하는 방법이라는 것이다.</p>
<p>이 논문을 읽을 때 막히는 지점은 대체로 세 곳이다.</p>
<ol>
<li class="">spike function이 왜 역전파에서 죽은 gradient를 만드는가.</li>
<li class="">BPTT가 시간축 신경망에서 무엇을 전파하는가.</li>
<li class="">“진짜 미분”이 아닌 surrogate derivative를 써도 왜 학습이 되는가.</li>
</ol>
<p>그래서 아래 로드맵은 논문을 연도순이 아니라 <strong>의존성 순서</strong>로 배치한다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: Surrogate Gradient</div><div class="admonitionContent_BuS1"><p>미분할 수 없는 스파이크 함수 대신, 역전파 때만 미분 가능한 대리 함수를 끼워 넣어 가중치를 업데이트하는 방법이다.</p><p>예: 실제 신호등은 빨강에서 초록으로 갑자기 바뀌지만, 운전 연습용 시뮬레이터에서는 그 경계 근처를 부드럽게 처리해 “조금 더 빨리 멈췄어야 한다”는 피드백을 줄 수 있게 만드는 것과 비슷하다.</p></div></div>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="1단계-스파이크-뉴런은-함수가-아니라-동역학이다">1단계: 스파이크 뉴런은 함수가 아니라 동역학이다<a href="https://ql.gl/ko/blog/d657d100/#1%EB%8B%A8%EA%B3%84-%EC%8A%A4%ED%8C%8C%EC%9D%B4%ED%81%AC-%EB%89%B4%EB%9F%B0%EC%9D%80-%ED%95%A8%EC%88%98%EA%B0%80-%EC%95%84%EB%8B%88%EB%9D%BC-%EB%8F%99%EC%97%AD%ED%95%99%EC%9D%B4%EB%8B%A4" class="hash-link" aria-label="1단계: 스파이크 뉴런은 함수가 아니라 동역학이다에 대한 직접 링크" title="1단계: 스파이크 뉴런은 함수가 아니라 동역학이다에 대한 직접 링크" translate="no">​</a></h2>
<h3 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="gerstner--kistler-spiking-neuron-models">Gerstner &amp; Kistler, Spiking Neuron Models<a href="https://ql.gl/ko/blog/d657d100/#gerstner--kistler-spiking-neuron-models" class="hash-link" aria-label="Gerstner &amp; Kistler, Spiking Neuron Models에 대한 직접 링크" title="Gerstner &amp; Kistler, Spiking Neuron Models에 대한 직접 링크" translate="no">​</a></h3>
<p>SNN 입문서로 가장 먼저 잡기 좋은 축이다. Leaky Integrate-and-Fire, spike response model, refractory period, synaptic current 같은 기본 단어가 여기서 정리된다. Surrogate Gradient 논문에서 막전위 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>u</mi><mo stretchy="false">(</mo><mi>t</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">u(t)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal">u</span><span class="mopen">(</span><span class="mord mathnormal">t</span><span class="mclose">)</span></span></span></span>, threshold, reset을 자연스럽게 읽으려면 이 계층이 필요하다.</p>
<p>핵심은 SNN 뉴런이 단순히 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>y</mi><mo>=</mo><mi>f</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">y = f(x)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em"></span><span class="mord mathnormal" style="margin-right:0.0359em">y</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.1076em">f</span><span class="mopen">(</span><span class="mord mathnormal">x</span><span class="mclose">)</span></span></span></span>를 계산하는 노드가 아니라는 점이다. 뉴런은 시간에 따라 입력 전류를 누적하고, 막전위가 임계값을 넘으면 spike를 내보낸 뒤 상태를 reset한다. 이때 출력 spike는 대략 Heaviside step function처럼 행동한다.</p>
<h3 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="izhikevich-simple-model-of-spiking-neurons">Izhikevich, Simple Model of Spiking Neurons<a href="https://ql.gl/ko/blog/d657d100/#izhikevich-simple-model-of-spiking-neurons" class="hash-link" aria-label="Izhikevich, Simple Model of Spiking Neurons에 대한 직접 링크" title="Izhikevich, Simple Model of Spiking Neurons에 대한 직접 링크" translate="no">​</a></h3>
<p>Izhikevich 모델은 Hodgkin-Huxley류의 생물학적 세부성과 LIF류의 계산 효율 사이에서 좋은 균형점을 보여준다. 이 논문을 읽으면 “스파이크 모델은 하나가 아니라 목적에 따라 추상화 수준이 다르다”는 감각을 얻는다.</p>
<p>Surrogate Gradient 관점에서는 이 차이가 중요하다. 어떤 뉴런 모델을 쓰든 학습 문제의 병목은 비슷하다. spike가 발생하는 순간은 불연속이고, 그 순간을 포함한 계산 그래프는 일반적인 ANN처럼 매끈하지 않다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="2단계-역전파는-연쇄-법칙을-계산-그래프로-밀어-넣는-기술이다">2단계: 역전파는 연쇄 법칙을 계산 그래프로 밀어 넣는 기술이다<a href="https://ql.gl/ko/blog/d657d100/#2%EB%8B%A8%EA%B3%84-%EC%97%AD%EC%A0%84%ED%8C%8C%EB%8A%94-%EC%97%B0%EC%87%84-%EB%B2%95%EC%B9%99%EC%9D%84-%EA%B3%84%EC%82%B0-%EA%B7%B8%EB%9E%98%ED%94%84%EB%A1%9C-%EB%B0%80%EC%96%B4-%EB%84%A3%EB%8A%94-%EA%B8%B0%EC%88%A0%EC%9D%B4%EB%8B%A4" class="hash-link" aria-label="2단계: 역전파는 연쇄 법칙을 계산 그래프로 밀어 넣는 기술이다에 대한 직접 링크" title="2단계: 역전파는 연쇄 법칙을 계산 그래프로 밀어 넣는 기술이다에 대한 직접 링크" translate="no">​</a></h2>
<h3 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="rumelhart-hinton-williams-learning-representations-by-back-propagating-errors">Rumelhart, Hinton, Williams, Learning representations by back-propagating errors<a href="https://ql.gl/ko/blog/d657d100/#rumelhart-hinton-williams-learning-representations-by-back-propagating-errors" class="hash-link" aria-label="Rumelhart, Hinton, Williams, Learning representations by back-propagating errors에 대한 직접 링크" title="Rumelhart, Hinton, Williams, Learning representations by back-propagating errors에 대한 직접 링크" translate="no">​</a></h3>
<p>역전파의 고전이다. 이 논문을 읽어야 하는 이유는 “딥러닝이 왜 gradient를 필요로 하는가”를 가장 압축적으로 보여주기 때문이다. 각 층의 local derivative를 곱해서 loss가 weight에 미치는 영향을 계산한다. 즉, 미분 가능한 구성요소들이 chain rule로 연결되어야 한다.</p>
<p>SNN에서 문제는 바로 여기에 생긴다. spike 출력 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>s</mi><mo>=</mo><mi>H</mi><mo stretchy="false">(</mo><mi>u</mi><mo>−</mo><mi>ϑ</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">s = H(u - \vartheta)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em"></span><span class="mord mathnormal">s</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.0813em">H</span><span class="mopen">(</span><span class="mord mathnormal">u</span><span class="mspace" style="margin-right:0.2222em"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal">ϑ</span><span class="mclose">)</span></span></span></span>를 생각하면, threshold 밖에서는 derivative가 거의 0이고 threshold 지점에서는 정의되지 않는다. 대부분의 시간에는 gradient가 흐르지 않고, 중요한 순간에는 수학적으로 깨진다.</p>
<h3 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="werbos-backpropagation-through-time">Werbos, Backpropagation through time<a href="https://ql.gl/ko/blog/d657d100/#werbos-backpropagation-through-time" class="hash-link" aria-label="Werbos, Backpropagation through time에 대한 직접 링크" title="Werbos, Backpropagation through time에 대한 직접 링크" translate="no">​</a></h3>
<p>SNN은 시간축을 가진 recurrent dynamical system이다. 그래서 단순 backpropagation만으로는 부족하고, 시간으로 펼친 계산 그래프에 대해 BPTT를 이해해야 한다. Werbos의 BPTT 논문은 recurrent state가 시간에 따라 어떻게 credit assignment를 받는지 설명하는 배경이다.</p>
<p>Surrogate Gradient 논문에서 “temporal credit assignment”가 반복해서 등장하는 이유도 여기에 있다. spike 하나가 현재 loss에만 영향을 주는 것이 아니라, 이후 막전위와 미래 spike에도 영향을 준다.</p>
<h3 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="bengio-et-al-estimating-or-propagating-gradients-through-stochastic-neurons">Bengio et al., Estimating or Propagating Gradients Through Stochastic Neurons<a href="https://ql.gl/ko/blog/d657d100/#bengio-et-al-estimating-or-propagating-gradients-through-stochastic-neurons" class="hash-link" aria-label="Bengio et al., Estimating or Propagating Gradients Through Stochastic Neurons에 대한 직접 링크" title="Bengio et al., Estimating or Propagating Gradients Through Stochastic Neurons에 대한 직접 링크" translate="no">​</a></h3>
<p>이 논문은 SNN 논문은 아니지만 Surrogate Gradient를 이해하는 데 매우 중요하다. hard non-linearity나 stochastic binary neuron을 학습할 때 gradient를 어떻게 추정할 것인가를 다룬다. 여기서 straight-through estimator가 등장한다.</p>
<p>SNN의 Surrogate Gradient는 넓게 보면 이 계열의 아이디어다. forward에서는 hard decision을 유지하고, backward에서는 유용한 gradient 신호를 흘려보낸다. “정확한 미분”보다 “학습에 쓸 수 있는 신호”가 중요하다는 관점이 여기서 열린다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: Straight-through estimator</div><div class="admonitionContent_BuS1"><p>순전파에서는 딱딱한 이산 결정을 그대로 쓰고, 역전파에서는 그 결정이 마치 identity나 smooth function이었던 것처럼 gradient를 통과시키는 근사 기법이다.</p><p>예: 시험 점수는 합격과 불합격으로만 발표하지만, 공부 피드백은 “몇 점 부족했는지”까지 알려주는 방식과 비슷하다.</p></div></div>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="3단계-surrogate-gradient-이전의-snn-학습법을-알아야-한다">3단계: Surrogate Gradient 이전의 SNN 학습법을 알아야 한다<a href="https://ql.gl/ko/blog/d657d100/#3%EB%8B%A8%EA%B3%84-surrogate-gradient-%EC%9D%B4%EC%A0%84%EC%9D%98-snn-%ED%95%99%EC%8A%B5%EB%B2%95%EC%9D%84-%EC%95%8C%EC%95%84%EC%95%BC-%ED%95%9C%EB%8B%A4" class="hash-link" aria-label="3단계: Surrogate Gradient 이전의 SNN 학습법을 알아야 한다에 대한 직접 링크" title="3단계: Surrogate Gradient 이전의 SNN 학습법을 알아야 한다에 대한 직접 링크" translate="no">​</a></h2>
<h3 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="bi--poo-spike-timing-dependent-plasticity">Bi &amp; Poo, Spike-Timing-Dependent Plasticity<a href="https://ql.gl/ko/blog/d657d100/#bi--poo-spike-timing-dependent-plasticity" class="hash-link" aria-label="Bi &amp; Poo, Spike-Timing-Dependent Plasticity에 대한 직접 링크" title="Bi &amp; Poo, Spike-Timing-Dependent Plasticity에 대한 직접 링크" translate="no">​</a></h3>
<p>STDP는 SNN의 생물학적 학습 원리로 자주 등장한다. presynaptic spike와 postsynaptic spike의 시간 차이에 따라 synapse가 강화되거나 약화된다. 이 논문은 SNN이 왜 “local learning rule”과 함께 발전했는지를 보여준다.</p>
<p>하지만 deep supervised learning 관점에서는 한계도 분명하다. STDP는 지역적인 spike timing에는 자연스럽지만, 여러 층 뒤의 loss가 앞쪽 synapse에 어떤 책임을 물어야 하는지, 즉 global credit assignment를 직접 해결하지 않는다.</p>
<h3 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="bohte-kok-la-poutré-spikeprop">Bohte, Kok, La Poutré, SpikeProp<a href="https://ql.gl/ko/blog/d657d100/#bohte-kok-la-poutr%C3%A9-spikeprop" class="hash-link" aria-label="Bohte, Kok, La Poutré, SpikeProp에 대한 직접 링크" title="Bohte, Kok, La Poutré, SpikeProp에 대한 직접 링크" translate="no">​</a></h3>
<p>SpikeProp은 spike timing을 대상으로 error backpropagation을 시도한 초기 supervised SNN 논문이다. 이 논문은 Surrogate Gradient 이전에도 “스파이크 시간을 미분 가능한 대상으로 만들어 학습하자”는 시도가 있었다는 점을 보여준다.</p>
<p>다만 SpikeProp 계열은 spike timing 표현과 특정 조건에 강하게 의존한다. 현대적인 deep SNN에서 원하는 것은 더 일반적인 layer, convolution, recurrent 구조, event stream을 다루는 학습 규칙이다.</p>
<h3 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="diehl-et-al-fast-classifying-high-accuracy-spiking-deep-networks">Diehl et al., Fast-classifying, high-accuracy spiking deep networks<a href="https://ql.gl/ko/blog/d657d100/#diehl-et-al-fast-classifying-high-accuracy-spiking-deep-networks" class="hash-link" aria-label="Diehl et al., Fast-classifying, high-accuracy spiking deep networks에 대한 직접 링크" title="Diehl et al., Fast-classifying, high-accuracy spiking deep networks에 대한 직접 링크" translate="no">​</a></h3>
<p>ANN-to-SNN conversion 흐름을 대표하는 논문이다. 먼저 일반 ANN을 학습한 뒤, activation을 firing rate로 해석해 SNN으로 변환한다. 이 접근은 실용적이었다. 직접 SNN을 학습시키는 난제를 피하고, 이미 잘 학습되는 ANN의 이점을 가져올 수 있었기 때문이다.</p>
<p>그러나 conversion은 latency와 temporal coding의 장점을 제한할 수 있다. spike timing을 적극적으로 쓰기보다 rate approximation에 기대기 쉽고, 낮은 timestep에서 성능을 유지하기 어렵다. Surrogate Gradient가 중요한 이유는 SNN을 SNN답게 직접 학습시키는 길을 넓혔기 때문이다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="4단계-surrogate-gradient-계열의-핵심-논문들">4단계: Surrogate Gradient 계열의 핵심 논문들<a href="https://ql.gl/ko/blog/d657d100/#4%EB%8B%A8%EA%B3%84-surrogate-gradient-%EA%B3%84%EC%97%B4%EC%9D%98-%ED%95%B5%EC%8B%AC-%EB%85%BC%EB%AC%B8%EB%93%A4" class="hash-link" aria-label="4단계: Surrogate Gradient 계열의 핵심 논문들에 대한 직접 링크" title="4단계: Surrogate Gradient 계열의 핵심 논문들에 대한 직접 링크" translate="no">​</a></h2>
<h3 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="zenke--ganguli-superspike">Zenke &amp; Ganguli, SuperSpike<a href="https://ql.gl/ko/blog/d657d100/#zenke--ganguli-superspike" class="hash-link" aria-label="Zenke &amp; Ganguli, SuperSpike에 대한 직접 링크" title="Zenke &amp; Ganguli, SuperSpike에 대한 직접 링크" translate="no">​</a></h3>
<p>SuperSpike는 반드시 읽어야 한다. 이 논문은 deterministic integrate-and-fire neuron을 다층 네트워크에서 supervised learning으로 훈련하기 위해 surrogate gradient를 사용한다. arXiv 초록은 surrogate gradient approach로 voltage-based three-factor learning rule을 유도한다고 설명한다.</p>
<p>여기서 중요한 포인트는 “스파이크 함수를 부드럽게 바꿔서 forward도 바꾸자”가 아니라는 점이다. forward의 spike는 그대로 둔다. 대신 backward에서 threshold 근처에만 의미 있는 pseudo-derivative를 둔다. 이렇게 하면 spike timing pattern을 대상으로 하는 비선형 과제도 학습할 수 있다.</p>
<h3 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="shrestha--orchard-slayer">Shrestha &amp; Orchard, SLAYER<a href="https://ql.gl/ko/blog/d657d100/#shrestha--orchard-slayer" class="hash-link" aria-label="Shrestha &amp; Orchard, SLAYER에 대한 직접 링크" title="Shrestha &amp; Orchard, SLAYER에 대한 직접 링크" translate="no">​</a></h3>
<p>SLAYER는 spike layer error reassignment라는 이름 그대로, layer와 time을 따라 error를 재배치하는 학습 프레임워크다. arXiv 초록에서 강조하듯 spike generation function의 non-differentiability와 temporal credit assignment를 함께 다룬다. 또한 GPU 구현과 convolutional SNN 실험을 제시해 Surrogate Gradient류 방법이 실제 deep SNN 훈련 도구로 확장될 수 있음을 보여준다.</p>
<h3 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="wu-et-al-spatio-temporal-backpropagation">Wu et al., Spatio-Temporal Backpropagation<a href="https://ql.gl/ko/blog/d657d100/#wu-et-al-spatio-temporal-backpropagation" class="hash-link" aria-label="Wu et al., Spatio-Temporal Backpropagation에 대한 직접 링크" title="Wu et al., Spatio-Temporal Backpropagation에 대한 직접 링크" translate="no">​</a></h3>
<p>STBP는 spatial domain과 temporal domain을 함께 전파한다는 관점이 뚜렷하다. Frontiers 초록은 spike activity의 non-differentiable 문제를 approximate derivative로 해결하고, layer-by-layer spatial domain과 timing-dependent temporal domain을 결합한다고 설명한다.</p>
<p>SNN을 단순히 “ANN에 spike를 붙인 것”이 아니라 시간축 신호처리 모델로 읽으려면 이 논문이 좋다.</p>
<h3 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="bellec-et-al-long-short-term-memory-and-learning-to-learn-in-networks-of-spiking-neurons">Bellec et al., Long short-term memory and learning-to-learn in networks of spiking neurons<a href="https://ql.gl/ko/blog/d657d100/#bellec-et-al-long-short-term-memory-and-learning-to-learn-in-networks-of-spiking-neurons" class="hash-link" aria-label="Bellec et al., Long short-term memory and learning-to-learn in networks of spiking neurons에 대한 직접 링크" title="Bellec et al., Long short-term memory and learning-to-learn in networks of spiking neurons에 대한 직접 링크" translate="no">​</a></h3>
<p>LSNN 논문은 recurrent SNN이 BPTT와 adaptation을 만나면 LSTM에 가까운 능력을 낼 수 있음을 보여준다. 초록은 RSNN의 성능이 ANN보다 약했던 이유 중 하나로 최적화 부재를 들고, BPTT 같은 강력한 최적화가 기능적 기여를 근사할 수 있다고 설명한다.</p>
<p>Surrogate Gradient를 “classification trick”으로만 보면 시야가 좁다. 이 논문을 읽으면 SNN 학습이 memory, adaptation, learning-to-learn으로 확장되는 길이 보인다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="5단계-목표-리뷰로-돌아오기">5단계: 목표 리뷰로 돌아오기<a href="https://ql.gl/ko/blog/d657d100/#5%EB%8B%A8%EA%B3%84-%EB%AA%A9%ED%91%9C-%EB%A6%AC%EB%B7%B0%EB%A1%9C-%EB%8F%8C%EC%95%84%EC%98%A4%EA%B8%B0" class="hash-link" aria-label="5단계: 목표 리뷰로 돌아오기에 대한 직접 링크" title="5단계: 목표 리뷰로 돌아오기에 대한 직접 링크" translate="no">​</a></h2>
<p>이제 Neftci, Mostafa, Zenke의 리뷰로 돌아오면 구조가 훨씬 선명해진다.</p>
<ul>
<li class="">spike는 binary하고 dynamical하므로 일반 ANN보다 학습이 어렵다.</li>
<li class="">local plasticity는 생물학적으로 자연스럽지만 deep supervised objective에는 부족하다.</li>
<li class="">conversion은 실용적이지만 spike timing과 low latency의 장점을 제한할 수 있다.</li>
<li class="">surrogate derivative는 forward의 event-driven spike를 보존하면서 backward의 gradient bottleneck을 뚫는다.</li>
</ul>
<p>따라서 Surrogate Gradient의 핵심은 “뇌를 완전히 모사한다”가 아니다. 더 정확히는 <strong>event-driven SNN이라는 계산 모델을 gradient-based optimization 생태계로 끌어오는 인터페이스</strong>다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="읽는-순서-요약">읽는 순서 요약<a href="https://ql.gl/ko/blog/d657d100/#%EC%9D%BD%EB%8A%94-%EC%88%9C%EC%84%9C-%EC%9A%94%EC%95%BD" class="hash-link" aria-label="읽는 순서 요약에 대한 직접 링크" title="읽는 순서 요약에 대한 직접 링크" translate="no">​</a></h2>
<table><thead><tr><th style="text-align:right">순서</th><th>논문</th><th>읽는 이유</th></tr></thead><tbody><tr><td style="text-align:right">1</td><td>Gerstner &amp; Kistler, <em>Spiking Neuron Models</em></td><td>LIF, threshold, reset, spike train 언어 익히기</td></tr><tr><td style="text-align:right">2</td><td>Izhikevich, <em>Simple Model of Spiking Neurons</em></td><td>뉴런 모델의 추상화 수준 이해</td></tr><tr><td style="text-align:right">3</td><td>Rumelhart et al., <em>Back-propagating errors</em></td><td>gradient learning의 원형 이해</td></tr><tr><td style="text-align:right">4</td><td>Werbos, <em>Backpropagation through time</em></td><td>시간축 credit assignment 이해</td></tr><tr><td style="text-align:right">5</td><td>Bengio et al., <em>Stochastic neurons and hard non-linearities</em></td><td>straight-through estimator와 hard decision 학습 이해</td></tr><tr><td style="text-align:right">6</td><td>Bi &amp; Poo, <em>STDP</em></td><td>local plasticity의 장점과 한계 이해</td></tr><tr><td style="text-align:right">7</td><td>Bohte et al., <em>SpikeProp</em></td><td>초기 supervised spike learning 시도 확인</td></tr><tr><td style="text-align:right">8</td><td>Diehl et al., <em>ANN-to-SNN conversion</em></td><td>direct training 이전의 실용 경로 이해</td></tr><tr><td style="text-align:right">9</td><td>Zenke &amp; Ganguli, <em>SuperSpike</em></td><td>surrogate derivative의 핵심 구현 이해</td></tr><tr><td style="text-align:right">10</td><td>SLAYER, STBP, LSNN</td><td>deep, temporal, recurrent SNN 확장 이해</td></tr><tr><td style="text-align:right">11</td><td>Neftci et al., <em>Surrogate Gradient Learning in SNNs</em></td><td>전체 흐름을 리뷰로 통합</td></tr></tbody></table>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="읽을-때-붙잡아야-할-질문">읽을 때 붙잡아야 할 질문<a href="https://ql.gl/ko/blog/d657d100/#%EC%9D%BD%EC%9D%84-%EB%95%8C-%EB%B6%99%EC%9E%A1%EC%95%84%EC%95%BC-%ED%95%A0-%EC%A7%88%EB%AC%B8" class="hash-link" aria-label="읽을 때 붙잡아야 할 질문에 대한 직접 링크" title="읽을 때 붙잡아야 할 질문에 대한 직접 링크" translate="no">​</a></h2>
<ol>
<li class="">이 논문은 spike를 rate로 보는가, timing으로 보는가.</li>
<li class="">학습 신호는 local인가, global loss에서 오는가.</li>
<li class="">시간축 credit assignment를 명시적으로 처리하는가.</li>
<li class="">forward의 spike는 그대로 두고 backward만 근사하는가.</li>
<li class="">neuromorphic hardware의 event-driven 장점과 얼마나 잘 맞는가.</li>
</ol>
<p>이 다섯 질문을 들고 읽으면 Surrogate Gradient는 단순한 “미분 꼼수”가 아니라, SNN을 실용 AI 모델로 훈련시키기 위한 설계 선택지로 보인다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="sources">Sources<a href="https://ql.gl/ko/blog/d657d100/#sources" class="hash-link" aria-label="Sources에 대한 직접 링크" title="Sources에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class=""><a href="https://arxiv.org/abs/1901.09948" target="_blank" rel="noopener noreferrer" class="">Neftci, Mostafa, Zenke, <em>Surrogate Gradient Learning in Spiking Neural Networks</em></a> — license: <code>unknown</code>, retrieved: <code>2026-07-13</code></li>
<li class=""><a href="https://arxiv.org/abs/1705.11146" target="_blank" rel="noopener noreferrer" class="">Zenke &amp; Ganguli, <em>SuperSpike: Supervised Learning in Multilayer Spiking Neural Networks</em></a> — license: <code>unknown</code>, retrieved: <code>2026-07-13</code></li>
<li class=""><a href="https://arxiv.org/abs/1810.08646" target="_blank" rel="noopener noreferrer" class="">Shrestha &amp; Orchard, <em>SLAYER: Spike Layer Error Reassignment in Time</em></a> — license: <code>unknown</code>, retrieved: <code>2026-07-13</code></li>
<li class=""><a href="https://arxiv.org/abs/1803.09574" target="_blank" rel="noopener noreferrer" class="">Bellec et al., <em>Long short-term memory and learning-to-learn in networks of spiking neurons</em></a> — license: <code>unknown</code>, retrieved: <code>2026-07-13</code></li>
<li class=""><a href="https://arxiv.org/abs/1308.3432" target="_blank" rel="noopener noreferrer" class="">Bengio et al., <em>Estimating or Propagating Gradients Through Stochastic Neurons for Conditional Computation</em></a> — license: <code>unknown</code>, retrieved: <code>2026-07-13</code></li>
<li class=""><a href="https://www.nature.com/articles/323533a0" target="_blank" rel="noopener noreferrer" class="">Rumelhart, Hinton, Williams, <em>Learning representations by back-propagating errors</em></a> — license: <code>unknown</code>, retrieved: <code>2026-07-13</code></li>
<li class=""><a href="https://doi.org/10.1109/5.58337" target="_blank" rel="noopener noreferrer" class="">Werbos, <em>Backpropagation through time: what it does and how to do it</em></a> — license: <code>unknown</code>, retrieved: <code>2026-07-13</code></li>
<li class=""><a href="https://neuronaldynamics.epfl.ch/online/index.html" target="_blank" rel="noopener noreferrer" class="">Gerstner &amp; Kistler, <em>Spiking Neuron Models</em></a> — license: <code>unknown</code>, retrieved: <code>2026-07-13</code></li>
<li class=""><a href="https://www.izhikevich.org/publications/spikes.htm" target="_blank" rel="noopener noreferrer" class="">Izhikevich, <em>Simple Model of Spiking Neurons</em></a> — license: <code>unknown</code>, retrieved: <code>2026-07-13</code></li>
<li class=""><a href="https://doi.org/10.1523/JNEUROSCI.18-24-10464.1998" target="_blank" rel="noopener noreferrer" class="">Bi &amp; Poo, <em>Synaptic Modifications in Cultured Hippocampal Neurons</em></a> — license: <code>unknown</code>, retrieved: <code>2026-07-13</code></li>
<li class=""><a href="https://doi.org/10.1016/S0925-2312(01)00658-0" target="_blank" rel="noopener noreferrer" class="">Bohte, Kok, La Poutré, <em>Error-backpropagation in temporally encoded networks of spiking neurons</em></a> — license: <code>unknown</code>, retrieved: <code>2026-07-13</code></li>
<li class=""><a href="https://arxiv.org/abs/1502.03114" target="_blank" rel="noopener noreferrer" class="">Diehl et al., <em>Fast-classifying, high-accuracy spiking deep networks through weight and threshold balancing</em></a> — license: <code>unknown</code>, retrieved: <code>2026-07-13</code></li>
<li class=""><a href="https://www.frontiersin.org/journals/neuroscience/articles/10.3389/fnins.2018.00331/full" target="_blank" rel="noopener noreferrer" class="">Wu et al., <em>Spatio-Temporal Backpropagation for Training High-performance Spiking Neural Networks</em></a> — license: <code>unknown</code>, retrieved: <code>2026-07-13</code></li>
<li class="">Image: <a href="https://ql.gl/ko/assets/files/cover-4819af83fc4e5aebe49f742d9aa75357.svg/" target="_blank" class="">Self-authored Surrogate Gradient paper roadmap cover diagram</a> — license: <code>original</code></li>
</ul>]]></content>
        <author>
            <name>p4r4d0xb0x</name>
            <uri>https://bdev.io</uri>
        </author>
        <category label="AI" term="AI"/>
        <category label="Neuromorphic" term="Neuromorphic"/>
        <category label="SNN" term="SNN"/>
        <category label="Research" term="Research"/>
        <category label="Explainer" term="Explainer"/>
    </entry>
    <entry>
        <title type="html"><![CDATA[HiPPO: 최적 다항 투영 기반 순환 메모리 — 논문 해설]]></title>
        <id>https://ql.gl/ko/blog/d3b70ba2/</id>
        <link href="https://ql.gl/ko/blog/d3b70ba2/"/>
        <updated>2026-07-11T00:00:00.000Z</updated>
        <summary type="html"><![CDATA[HiPPO 프레임워크를 통해 온라인 함수 근사 관점에서 순환 신경망의 메모리 문제를 재구성하고, LegS(Scaled Legendre) 업데이트의 직관·수학·실험적 이점을 단계별로 설명합니다.]]></summary>
        <content type="html"><![CDATA[<p><img decoding="async" loading="lazy" src="https://ql.gl/ko/assets/images/cover-d27c348672e7238072632de3cea8c109.webp" width="1200" height="670" class="img_ev3q"></p>
<p>이 글은 논문 "HiPPO: Recurrent Memory with Optimal Polynomial Projections"를 근거로, 저자가 제시한 HiPPO 프레임워크의 문제 의식, 수학적 직관, 핵심 방법(연속-시간 ODE와 이산화), 주요 결과와 한계까지 단계적으로 해설합니다. 목표는 단순 요약을 넘어서서, 왜 이런 관점이 필요한지(문제), 어떤 아이디어로 풀리는지(직관), 수식과 알고리즘은 어떻게 연결되는지(메커니즘)를 비전문가도 따라올 수 있게끔 차근차근 풀어내는 것입니다.</p>
<!-- -->
<p>문서 전체에서 논문은 "메모리 문제"를 "온라인 함수 근사(online function approximation)" 문제로 재정의합니다. 이 재정의가 가져오는 핵심 이득은 두 가지입니다. 첫째, 전통적인 RNN·LSTM·GRU에서 경험적으로 사용되던 여러 기법(슬라이딩 윈도우, 게이팅, LMU 등)을 하나의 이론적 틀로 통합해 이해할 수 있습니다. 둘째, 이 틀에서 적절한 '과거의 중요도'를 정의(측정)하면 그에 맞는 최적의 업데이트(연속 시간에서는 ODE, 이산 시간에서는 선형 점화식)를 닫힌형태로 유도할 수 있습니다.</p>
<p>이제 세부 항목을 차례대로 살펴보겠습니다.</p>
<p>문제와 동기</p>
<p>순차 데이터(언어, 센서, 의료 시계열 등)에서 핵심 과제는 "무한히 길어질 수 있는 과거를 제한된 상태(메모리)로 실시간 축약(compress)하는 방법"입니다. 기존 접근들은 보통 다음 둘 중 하나에 의존합니다: (1) 고정 길이의 슬라이딩 윈도우(최근 T만 기억), 또는 (2) 지수 감쇠와 같은 우선순위 부여(최근이 중요). 하지만 이들은 시간 스케일(예: 샘플링 속도 변화)에 민감하고, 분포 변화가 있을 때(예: 다른 주파수를 가진 신호) 성능이 급락하는 문제를 가집니다. 또한 많은 모델은 장기 의존성을 학습하는 과정에서 경사 소실/폭주 문제에 대해 이론적 보장이 약합니다.</p>
<p>HiPPO의 출발점은 간단합니다: "메모리"를 어떤 함수 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>f</mi><mo stretchy="false">(</mo><mi>t</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">f(t)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.1076em">f</span><span class="mopen">(</span><span class="mord mathnormal">t</span><span class="mclose">)</span></span></span></span>의 과거 구간에 대한 최적 근사 계수(coef)로 본다. 즉 과거 신호를 어떤 기저(basis) 위에 N차원으로 투영하여 그 계수만을 저장·갱신하면, 이것이 곧 압축된 역사 표현이 된다. 이 관점은 근사 이론과 직관적으로 맞닿아 있어, 어떤 측도(measure)로 과거의 중요도를 정의하느냐에 따라 '최적' 투영이 달라진다는 것을 명확히 해줍니다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: HiPPO</div><div class="admonitionContent_BuS1"><p>쉬운정의: HiPPO는 "High-order Polynomial Projection Operators"의 약어로, 시간에 따라 달라지는 측도에 대해 과거 신호를 다항식 기저에 투영하여 최적의 계수를 실시간으로 갱신하는 수학적 프레임워크입니다.
일상 예: 스마트폰에서 최근 몇 분치만 강조하느냐 전체 통화 내역을 요약하느냐를 정하는 규칙 같은 개념입니다.</p></div></div>
<p>핵심 아이디어: 온라인 함수 근사와 다항 투영</p>
<p>프레임워크의 핵심은 다음 세 단계로 요약됩니다. 첫째, 각 시점 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>t</mi></mrow><annotation encoding="application/x-tex">t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6151em"></span><span class="mord mathnormal">t</span></span></span></span>에 대해 과거 구간(예: <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mo>−</mo><mi mathvariant="normal">∞</mi><mo separator="true">,</mo><mi>t</mi><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">(-\infty,t]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mopen">(</span><span class="mord">−</span><span class="mord">∞</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em"></span><span class="mord mathnormal">t</span><span class="mclose">]</span></span></span></span>나 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">[</mo><mi>t</mi><mo>−</mo><mi>θ</mi><mo separator="true">,</mo><mi>t</mi><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">[t-\theta,t]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mopen">[</span><span class="mord mathnormal">t</span><span class="mspace" style="margin-right:0.2222em"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.0278em">θ</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em"></span><span class="mord mathnormal">t</span><span class="mclose">]</span></span></span></span> 등)에 대한 '중요도'를 측정하는 측도 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>μ</mi><mi>t</mi></msub></mrow><annotation encoding="application/x-tex">\mu_t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em"></span><span class="mord"><span class="mord mathnormal">μ</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.2806em"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em"><span class="pstrut" style="height:2.7em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight">t</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em"><span></span></span></span></span></span></span></span></span></span>를 고릅니다. 둘째, 이 측도에 대해 직교 다항(orthogonal polynomials) 계열을 기저로 선택하면, 과거 신호 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>f</mi></mrow><annotation encoding="application/x-tex">f</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em"></span><span class="mord mathnormal" style="margin-right:0.1076em">f</span></span></span></span>를 그 기저에 정사영(projection)했을 때 최적 계수는 내적 형태로 닫힌표현을 가집니다. 셋째, 이 계수들을 시간에 대해 미분하면(미분-교환을 통해) 계수 벡터 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>c</mi><mo stretchy="false">(</mo><mi>t</mi><mo stretchy="false">)</mo><mo>∈</mo><msup><mi mathvariant="double-struck">R</mi><mi>N</mi></msup></mrow><annotation encoding="application/x-tex">c(t)\in\mathbb{R}^N</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal">c</span><span class="mopen">(</span><span class="mord mathnormal">t</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">∈</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:0.8413em"></span><span class="mord"><span class="mord mathbb">R</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8413em"><span style="top:-3.063em;margin-right:0.05em"><span class="pstrut" style="height:2.7em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.109em">N</span></span></span></span></span></span></span></span></span></span></span>가 선형 ODE 형태</p>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mfrac><mrow><mi>d</mi><mi>c</mi><mo stretchy="false">(</mo><mi>t</mi><mo stretchy="false">)</mo></mrow><mrow><mi>d</mi><mi>t</mi></mrow></mfrac><mo>=</mo><mi>A</mi><mo stretchy="false">(</mo><mi>t</mi><mo stretchy="false">)</mo><mi>c</mi><mo stretchy="false">(</mo><mi>t</mi><mo stretchy="false">)</mo><mo>+</mo><mi>B</mi><mo stretchy="false">(</mo><mi>t</mi><mo stretchy="false">)</mo><mi>f</mi><mo stretchy="false">(</mo><mi>t</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">{d c(t) \over d t} = A(t) c(t) + B(t) f(t)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.355em;vertical-align:-0.345em"></span><span class="mord"><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.01em"><span style="top:-2.655em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">d</span><span class="mord mathnormal mtight">t</span></span></span></span><span style="top:-3.23em"><span class="pstrut" style="height:3em"></span><span class="frac-line" style="border-bottom-width:0.04em"></span></span><span style="top:-3.485em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">d</span><span class="mord mathnormal mtight">c</span><span class="mopen mtight">(</span><span class="mord mathnormal mtight">t</span><span class="mclose mtight">)</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.345em"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span></span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal">A</span><span class="mopen">(</span><span class="mord mathnormal">t</span><span class="mclose">)</span><span class="mord mathnormal">c</span><span class="mopen">(</span><span class="mord mathnormal">t</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2222em"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.0502em">B</span><span class="mopen">(</span><span class="mord mathnormal">t</span><span class="mclose">)</span><span class="mord mathnormal" style="margin-right:0.1076em">f</span><span class="mopen">(</span><span class="mord mathnormal">t</span><span class="mclose">)</span></span></span></span></p>
<p>을 만족한다는 사실이 나옵니다. 즉 최적의 계수 갱신은 간단한 선형 역학으로 구현될 수 있고, 이를 이산화하면 효율적인 점화식이 됩니다.</p>
<p>이 관점이 중요한 이유는, 여러 기존 기법(예: LMU, 게이팅 RNN)이 HiPPO의 특수한 선택으로 유도된다는 것입니다. 따라서 이 프레임워크는 "어떻게 메모리를 설계해야 하는가"에 대한 통합된 이론을 제공합니다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: orthogonal polynomials (직교 다항)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 어떤 측도(가중치)에 대해 서로 직교하는 다항식들의 열입니다. 이 기저 위에서 함수를 전개하면 서로 간섭 없이 계수를 계산할 수 있습니다.
일상 예: 서로 직교하는 색상의 필터를 이용해 이미지를 분해하는 것과 비슷합니다; 각 필터가 겹치지 않게 정보를 잡아냅니다.</p></div></div>
<p>HiPPO의 수학적 직관과 ODE 도출</p>
<p>좀 더 구체적으로 보면, 공간 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>G</mi></mrow><annotation encoding="application/x-tex">G</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em"></span><span class="mord mathnormal">G</span></span></span></span>를 다항식 차수 N 미만의 공간으로 정하면 임의의 과거 함수의 최적투영은 그 직교 다항 기저의 내적들로 표현됩니다. 이때 시간에 따라 측도 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>μ</mi><mo stretchy="false">(</mo><mi>t</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">\mu(t)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal">μ</span><span class="mopen">(</span><span class="mord mathnormal">t</span><span class="mclose">)</span></span></span></span>가 변하므로 기저 자체가 시간에 따라 바뀔 수 있고, 기저의 변화와 내적의 경계(적분 상한이 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>t</mi></mrow><annotation encoding="application/x-tex">t</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6151em"></span><span class="mord mathnormal">t</span></span></span></span>)를 미분하면 자연스럽게 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>c</mi><mo stretchy="false">(</mo><mi>t</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">c(t)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal">c</span><span class="mopen">(</span><span class="mord mathnormal">t</span><span class="mclose">)</span></span></span></span>에 대한 선형 미분방정식이 도출됩니다. 중요한 직관은 "미분을 하면 현재 입력 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>f</mi><mo stretchy="false">(</mo><mi>t</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">f(t)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.1076em">f</span><span class="mopen">(</span><span class="mord mathnormal">t</span><span class="mclose">)</span></span></span></span>가 소스 항(source term)으로 나타나고, 이전 계수는 선형 결합(행렬 A에 의해)으로 재조합된다"는 점입니다.</p>
<p>이 선형 ODE는 두 가지 면에서 유용합니다. 첫째, 연속-시간 표현을 통해 근본적인 성질(예: 시간 스케일 변화에 대한 동치성, 경사 바운드)을 분석할 수 있습니다. 둘째, 수치적으로 안정된 이산화(discretization) 기법(예: bilinear transform, zero-order hold 등)을 쓰면 실제 순차 데이터에 바로 적용 가능한 점화식이 얻어집니다. 논문은 연속식 유도와 함께 여러 이산화 방법을 논의하며, 실제 실험에는 수치적으로 안정한 방법들을 사용했다고 밝혔습니다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: projection operator (정사영 연산자)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 어떤 함수(또는 벡터)를 주어진 부분공간 위로 옮겨 가장 가까운(오차가 최소인) 표현으로 바꾸는 연산자입니다.
일상 예: 긴 문장을 요약해 핵심 문장 몇 개로 만드는 편집 규칙과 유사합니다; 요약된 문장은 원문을 가장 잘 대표합니다.</p></div></div>
<p>특수 사례와 새로운 업데이트: LMU에서 HiPPO-LegS(Scaled Legendre)까지</p>
<p>논문은 HiPPO 프레임워크의 여러 측도 선택으로부터 기존 기법을 재도출하고, 새로운 메커니즘을 제안합니다. 대표적으로:</p>
<ul>
<li class="">
<p>LegT(Translated Legendre): 고정 길이 슬라이딩 윈도우 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">[</mo><mi>t</mi><mo>−</mo><mi>θ</mi><mo separator="true">,</mo><mi>t</mi><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">[t-\theta,t]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mopen">[</span><span class="mord mathnormal">t</span><span class="mspace" style="margin-right:0.2222em"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.0278em">θ</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em"></span><span class="mord mathnormal">t</span><span class="mclose">]</span></span></span></span>에 균일 가중을 주는 측도입니다. 이 경우 계수 갱신은 상수 행렬 A와 B를 갖는 LTI(linear time-invariant) ODE로 귀결되며, 이 식이 바로 이전에 제안된 Legendre Memory Unit(LMU) 업데이트를 엄밀한 원리에서 유도합니다. LMU는 고정 길이 창을 통해 과거를 요약하기 때문에 창 크기 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>θ</mi></mrow><annotation encoding="application/x-tex">\theta</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6944em"></span><span class="mord mathnormal" style="margin-right:0.0278em">θ</span></span></span></span>가 하이퍼파라미터로 필요합니다.</p>
</li>
<li class="">
<p>LagT(Laguerre-type): 지수 감쇠 측도로 최근을 더 강조하는 경우로, 지수 적분 가중에 따라 다른 A,B 행렬이 나옵니다.</p>
</li>
<li class="">
<p>LegS(Scaled Legendre): 논문이 제안하는 핵심 신규 아이디어 중 하나로, 측도를 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">[</mo><mn>0</mn><mo separator="true">,</mo><mi>t</mi><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">[0,t]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mopen">[</span><span class="mord">0</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em"></span><span class="mord mathnormal">t</span><span class="mclose">]</span></span></span></span> 전체에 균일하게 주되 "창이 시간에 따라 확장"되도록 스케일링합니다. 결과적으로 이 방법은 고정 창 크기나 하이퍼파라미터 없이도 과거 전체를 고려하는 업데이트를 생성합니다. 이 결과로 얻어지는 이산 점화식(논문 식(4) 등)은 시간 스케일 변화(입력이 압축되거나 확장되는 경우)에 대해 동치성(timescale-equivariance)을 갖습니다.</p>
</li>
</ul>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: LegS (Scaled Legendre)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 시간 t까지의 전체 과거를 균일하게 고려하도록 스케일된 Legendre 계열 기반의 메모리 업데이트 방식입니다. 고정된 윈도우 크기 없이도 과거 전체를 요약합니다.
일상 예: 사진을 찍을 때 매번 최근 10초만 보는 대신, 시간이 지나면서 자동으로 보는 범위를 넓혀 전체 여행의 흐름을 잃지 않는 타임랩스처럼 동작합니다.</p></div></div>
<p>왜 LegS가 중요한가? — 이론적 성질 해석</p>
<p>논문은 LegS에 대해 몇 가지 이론적 이점을 보입니다.</p>
<ul>
<li class="">
<p>시간 스케일 강건성(timescale robustness): 신호를 압축(또는 확장)해도(예: 샘플링 속도 변화) HiPPO-LegS의 계수는 동치성(equivariance)을 유지합니다. 정식 명제는: <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>h</mi><mo stretchy="false">(</mo><mi>t</mi><mo stretchy="false">)</mo><mo>=</mo><mi>f</mi><mo stretchy="false">(</mo><mi>α</mi><mi>t</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">h(t)=f(\alpha t)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal">h</span><span class="mopen">(</span><span class="mord mathnormal">t</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.1076em">f</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0037em">α</span><span class="mord mathnormal">t</span><span class="mclose">)</span></span></span></span>이면 hippo(h)(t)=hippo(f)(\alpha t)입니다. 직관적으로, LegS는 과거를 항상 "현재 시점까지의 상대적 위치"로 바라보기 때문에 절대적 시간 단위에 의존하지 않습니다.</p>
</li>
<li class="">
<p>계산 효율성: 일반적으로 N차원 상태 업데이트는 O(N^2) 행렬곱이 필요하지만, LegS의 A 행렬은 특수한 구조를 가지므로 모든 일반적인 이산화 방법에 대해 빠른 곱셈 알고리즘을 적용할 수 있습니다(논문은 행렬 구조를 이용한 빠른 구현 가능성을 증명합니다).</p>
</li>
<li class="">
<p>경사와 근사 오차에 대한 경계: HiPPO 프레임워크는 근본적으로 최적 투영 문제에서 출발하므로 근사 오차에 대한 정량적 보장을 유도할 수 있고, ODE 표현을 통해 경사 흐름(gradient flow)에 대한 상한을 확보할 수 있습니다. 이는 장기 의존성 학습에서 경사 소실/폭주 문제를 일부 완화하는 단서를 제공합니다.</p>
</li>
</ul>
<p>실험적 결과와 의미</p>
<p>논문에서 보고한 핵심 실험적 결과는 다음과 같습니다(증거 팩 인용):</p>
<ul>
<li class="">
<p>permuted MNIST 벤치마크: HiPPO-LegS는 하이퍼파라미터 없이 98.3%의 정확도를 기록하며 이전 RNN 기반 SoTA를 1포인트 이상 능가하고, 심지어 전역 문맥을 쓰는 트랜스포머 계열 모델들과도 경쟁력 있는 성능을 보였다고 보고합니다. 이는 짧은 메모리 창을 넘어서 장기 의존성을 안정적으로 캡처할 수 있음을 시사합니다.</p>
</li>
<li class="">
<p>트래젝토리 분류(시간 스케일 변화 및 결측에 강건한 신규 태스크): LegS는 RNN 및 neural ODE 계열에 비해 25–40%의 절대 성능 향상을 보였다고 보고합니다. 이 결과는 시간 스케일 분포가 훈련과 달리 바뀌는 상황에서 LegS의 동치성이 실제로 일반화 성능 향상으로 연결됨을 보여줍니다.</p>
</li>
<li class="">
<p>확장성 검증: 논문은 HiPPO 기반 연산이 수백만 시점에 대해 빠르고 정확한 온라인 재구성이 가능하다고 주장합니다(세부 구현·하이퍼파라미터는 코드 저장소 <a href="https://github.com/HazyResearch/hippo-code" target="_blank" rel="noopener noreferrer" class="">https://github.com/HazyResearch/hippo-code</a> 에 있음).</p>
</li>
</ul>
<p>한계와 불확실성</p>
<p>모든 논문과 마찬가지로 몇 가지 한계와 확인되지 않은 점이 남아 있습니다.</p>
<ul>
<li class="">
<p>실험 재현성·세부: 증거 팩은 핵심 결과(예: 98.3%)와 주요 실험 설계를 보고하지만, 하이퍼파라미터 튜닝 과정, 초기화 민감도, 각 태스크별 학습 곡선과 통계적 유의성 등의 상세는 본문 요약만으로는 완전하게 복원되지 않습니다. 코드 저장소가 공개되어 있으므로 구현 상세는 그곳을 참조해야 합니다.</p>
</li>
<li class="">
<p>이산화 민감도: 연속-시간 ODE를 이산화하는 과정은 수치적 안정성에 민감합니다. 논문은 안정한 이산화 기법을 사용했다고 밝히지만, 실전에서는 선택한 이산화 방법 및 스텝 크기 정책이 성능에 영향을 줄 수 있습니다.</p>
</li>
<li class="">
<p>표현력의 한계: HiPPO는 과거를 다항식 기저로 근사하는 접근입니다. 매우 비정형적이거나 급격한 변화가 많은 신호에서는 다항 근사 자체의 한계로 인한 오차가 발생할 수 있으며, 논문은 다양한 측도를 통해 트레이드오프를 분석하지만 모든 신호 유형에 무조건적 우월을 주장하지는 않습니다.</p>
</li>
</ul>
<p>실용적 시사점</p>
<p>연구와 엔지니어링 관점에서 몇 가지 결론을 권합니다. 첫째, 장기 의존성 학습이 중요한 문제(예: 센서 데이터, 생체 신호, 일부 언어 태스크)에는 측도 기반의 메모리 설계를 고려해볼 만합니다. 둘째, 데이터 수집 환경에서 시간 스케일이 변할 가능성이 있다면(샘플링 주파수 변화 등) LegS 같은 스케일 불변성 메커니즘은 모델의 일반화 안정성을 높여줍니다. 셋째, 이론적 보장이 있는 메커니즘을 도입하면(예: 경사 바운드) 최적화 안정성을 향상시킬 여지가 있으므로, 실제 대형 학습 파이프라인에서의 적용성 검증이 다음 과제입니다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: LMU (Legendre Memory Unit)</div><div class="admonitionContent_BuS1"><p>쉬운정의: LMU는 고정 길이의 슬라이딩 윈도우에서 Legendre 다항 기저로 과거를 요약하는 메모리 유닛입니다. HiPPO에서는 LegT 측도의 특수 사례로 재도출됩니다.
일상 예: 최근 1시간 동안의 평균 온도를 항상 계산해두는 장치처럼, 고정된 기간만 기억하는 방식입니다.</p></div></div>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="논문-구조-분석">논문 구조 분석<a href="https://ql.gl/ko/blog/d3b70ba2/#%EB%85%BC%EB%AC%B8-%EA%B5%AC%EC%A1%B0-%EB%B6%84%EC%84%9D" class="hash-link" aria-label="논문 구조 분석에 대한 직접 링크" title="논문 구조 분석에 대한 직접 링크" translate="no">​</a></h2>
<p>(1) IMRaD 판별 및 매핑</p>
<p>제공된 evidence pack와 탐지된 헤딩을 토대로 이 논문은 전형적인 IMRaD(Introduction, Methods, Results, Discussion) 중 일부 요소를 명확히 갖추고 있으나 전형적 IMRaD와 완전히 일치하지는 않습니다. 구체적으로:</p>
<ul>
<li class="">Introduction: "1 Introduction" 섹션이 명확히 존재하며 문제 제기와 목적(통합적 프레임워크 제시, 시계열에서의 시간 스케일 무관성 등)을 제시합니다.</li>
<li class="">Methods: "Section 2 The HiPPO Framework" 및 이어지는 세부절(2.1~2.5, 연속-시간 유도와 이산화 방안, 여러 측도 인스턴스)이 방법론(IM) 역할을 합니다. 이 부분에서 정의(Definition 1), ODE 도출, 특정 측도별 A,B 행렬 유도 등 수학적 기여가 집중적으로 설명됩니다.</li>
<li class="">Results: 실험(Section 4 관련)과 이론적 정리(Section 3의 성질 증명)는 결과에 해당합니다. permuted MNIST 성능, 트래젝토리 분류 태스크, 스케일 강건성 실험 등이 핵심 결과로 보고됩니다.</li>
<li class="">Discussion: 명시적인 "Discussion" 섹션은 탐지된 구조에 포함되어 있지 않습니다. 대신 논문은 방법론과 결과 사이에 관련 작업(Related Work)과 부록(appendix)에 많은 분석·증명·추가 실험을 배치하는 스타일입니다. 즉 전형적 IMRaD의 "Discussion"은 결과 섹션 내에서 합쳐지거나 결론부와 부록으로 분산되어 있습니다.</li>
</ul>
<p>따라서 IMRaD 판별 결과는 "부분적으로 따름"입니다: Introduction, Methods, Results는 존재하지만 독립적인 Discussion 섹션은 부재(또는 분산)합니다.</p>
<p>(2) 논문의 논리적 흐름(큰그림 → 작은그림)</p>
<p>구조적 흐름은 문제→갭→기여(problem→gap→contribution) 형태로 매우 직선적이며 논리적으로 일관되어 있습니다. 보다 구체적으로:</p>
<ul>
<li class="">문제 제기(Introduction): 순차 데이터에서의 메모리 문제와 기존 방법들의 한계(시간 스케일에 대한 priors 필요, 이론적 보장 부족)를 제시합니다.</li>
<li class="">개념적 재정의(Methods 초입): 메모리를 "온라인 함수 근사"로 재정의하여 어떤 측도로 과거의 중요도를 정할지를 중심 개념으로 도입합니다. 이 단계에서 "왜 다항 기저인가"에 대한 근거(직교 다항의 닫힌형 계수 표현)를 제공합니다.</li>
<li class="">수학적 전개(Methods 심화): 기저 선택, 내적 미분, ODE 도출, 그리고 이산화로의 연결을 통해 알고리즘적 구현(점화식)까지 이어지는 작은그림으로 내려갑니다. 이 과정에서 LMU 같은 기존 기법을 특수 사례로 복원하고, LegS 같은 신규 메커니즘을 도출해냅니다.</li>
<li class="">이론·실험 검증(Results): 도출된 메커니즘의 이론적 성질(동치성, 계산 복잡도, 경사 바운드)과 실험적 우수성을 각각 별도의 섹션에서 증명·보고합니다.</li>
</ul>
<p>이러한 전개는 "왜 이 방법이 필요한가"(동기)에서 시작해 "어떻게 형성되는가"(수학적 유도), 그리고 "실제로 유용한가"(실험)로 자연스럽게 이어집니다. 추가로 상세한 증명과 비교는 부록에 배치되어 있어 논문의 흐름은 읽는 이를 큰그림에서 작은그림으로 단계적으로 안내하도록 설계되어 있습니다.</p>
<p>끝.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="sources">Sources<a href="https://ql.gl/ko/blog/d3b70ba2/#sources" class="hash-link" aria-label="Sources에 대한 직접 링크" title="Sources에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class=""><a href="https://arxiv.org/pdf/2008.07669" target="_blank" rel="noopener noreferrer" class="">HiPPO: Recurrent Memory with Optimal Polynomial Projections</a> — license: <code>unknown</code>, retrieved: <code>2026-07-11</code>.</li>
<li class="">Image: <a href="https://ql.gl/ko/assets/files/cover-d27c348672e7238072632de3cea8c109.webp/" target="_blank" class="">AI-generated cover image via OpenRouter</a> — license: <code>ai-generated-original</code>.</li>
</ul>]]></content>
        <author>
            <name>p4r4d0xb0x</name>
            <uri>https://bdev.io</uri>
        </author>
        <category label="Research" term="Research"/>
        <category label="AI" term="AI"/>
        <category label="Explainer" term="Explainer"/>
    </entry>
    <entry>
        <title type="html"><![CDATA[르장드르 변환: 직관, 사례, 열역학적 연결]]></title>
        <id>https://ql.gl/ko/blog/3551c399/</id>
        <link href="https://ql.gl/ko/blog/3551c399/"/>
        <updated>2026-07-10T00:00:00.000Z</updated>
        <summary type="html"><![CDATA[르장드르 변환의 직관적 의미와 수학적 정의, 조화 퍼텐셜 예시를 통한 작동 방식, 그리고 라플라스 변환을 통한 분배 함수 및 자유에너지와의 연결을 자세히 설명합니다. 핵심 아이디어마다 문제-직관-의미의 흐름으로 단계별 해설을 제공합니다.]]></summary>
        <content type="html"><![CDATA[<p><img decoding="async" loading="lazy" src="https://ql.gl/ko/assets/images/cover-1ef0e95548d417e01a7aa73ac013c8cf.webp" width="1200" height="670" class="img_ev3q"></p>
<!-- -->
<p>르장드르 변환(Legendre transform)은 '어떤 함수가 가진 정보를 다른 제어 변수(혹은 공변수) 관점에서 다시 표현'하고자 할 때 쓰는 표준 도구입니다. 이 글에서는 왜 이 도구가 필요한지(문제), 어떻게 동작하는지(직관과 수식), 그리고 물리학-특히 통계열역학에서 왜 중요한지(의미)를 단계별로 설명합니다. 각 단계에서 가능한 한 구체적 예시와 비유를 사용해 핵심 개념을 직관적으로 파악하도록 돕겠습니다.</p>
<p>르장드르 변환을 처음 만났을 때 흔히 생기는 질문은 간단합니다: "원래의 변수 대신 다른 변수를 도입하면 무슨 이득이 있는가? 원래 정보가 손실되지는 않는가?" 이 질문에 답하려면 두 가지 요소를 살펴야 합니다. 첫째, 원래 함수가 충분히 볼록(convex)해서 도함수와 원래 변수가 일대일 대응을 이루는가, 둘째, 실험적·이론적으로 어떤 변수를 다루기가 더 쉬운가입니다. 다음 절에서 이 점들을 더 엄밀히 다루고, 기하학적 직관(접선과 절편)을 통해 공식이 왜 자연스럽게 나오는지 보여주겠습니다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="1-문제-설정과-기하학적-직관">1. 문제 설정과 기하학적 직관<a href="https://ql.gl/ko/blog/3551c399/#1-%EB%AC%B8%EC%A0%9C-%EC%84%A4%EC%A0%95%EA%B3%BC-%EA%B8%B0%ED%95%98%ED%95%99%EC%A0%81-%EC%A7%81%EA%B4%80" class="hash-link" aria-label="1. 문제 설정과 기하학적 직관에 대한 직접 링크" title="1. 문제 설정과 기하학적 직관에 대한 직접 링크" translate="no">​</a></h2>
<p>문제: 어떤 양 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>F</mi></mrow><annotation encoding="application/x-tex">F</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em"></span><span class="mord mathnormal" style="margin-right:0.1389em">F</span></span></span></span>가 독립 변수 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>x</mi></mrow><annotation encoding="application/x-tex">x</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em"></span><span class="mord mathnormal">x</span></span></span></span>에 의존한다고 하자. 즉 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>F</mi><mo>=</mo><mi>F</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">F=F(x)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em"></span><span class="mord mathnormal" style="margin-right:0.1389em">F</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.1389em">F</span><span class="mopen">(</span><span class="mord mathnormal">x</span><span class="mclose">)</span></span></span></span>이다. 하지만 실제로는 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>x</mi></mrow><annotation encoding="application/x-tex">x</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em"></span><span class="mord mathnormal">x</span></span></span></span>를 직접 다루기보다 그 기울기 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>s</mi><mo>=</mo><mi>d</mi><mi>F</mi><mi mathvariant="normal">/</mi><mi>d</mi><mi>x</mi></mrow><annotation encoding="application/x-tex">s=dF/dx</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em"></span><span class="mord mathnormal">s</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal">d</span><span class="mord mathnormal" style="margin-right:0.1389em">F</span><span class="mord">/</span><span class="mord mathnormal">d</span><span class="mord mathnormal">x</span></span></span></span>를 더 자연스럽게 측정하거나 제어할 수 있다. 이 경우 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>s</mi></mrow><annotation encoding="application/x-tex">s</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em"></span><span class="mord mathnormal">s</span></span></span></span>를 독립 변수로 하는 새로운 표현 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>G</mi><mo stretchy="false">(</mo><mi>s</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">G(s)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal">G</span><span class="mopen">(</span><span class="mord mathnormal">s</span><span class="mclose">)</span></span></span></span>를 만들고 싶다. 핵심 조건은 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>x</mi><mo>↦</mo><mi>s</mi></mrow><annotation encoding="application/x-tex">x\mapsto s</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.522em;vertical-align:-0.011em"></span><span class="mord mathnormal">x</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">↦</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:0.4306em"></span><span class="mord mathnormal">s</span></span></span></span> 변환이 역함수를 가지는 것이다. 수학적으로는</p>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mfrac><mrow><msup><mi>d</mi><mn>2</mn></msup><mi>F</mi></mrow><mrow><mi>d</mi><msup><mi>x</mi><mn>2</mn></msup></mrow></mfrac><mo>&gt;</mo><mn>0</mn></mrow><annotation encoding="application/x-tex">\frac{d^2 F}{dx^2} &gt; 0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.3629em;vertical-align:-0.345em"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.0179em"><span style="top:-2.655em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">d</span><span class="mord mtight"><span class="mord mathnormal mtight">x</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.7463em"><span style="top:-2.786em;margin-right:0.0714em"><span class="pstrut" style="height:2.5em"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span></span></span></span><span style="top:-3.23em"><span class="pstrut" style="height:3em"></span><span class="frac-line" style="border-bottom-width:0.04em"></span></span><span style="top:-3.394em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight"><span class="mord mathnormal mtight">d</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8913em"><span style="top:-2.931em;margin-right:0.0714em"><span class="pstrut" style="height:2.5em"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span><span class="mord mathnormal mtight" style="margin-right:0.1389em">F</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.345em"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">&gt;</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:0.6444em"></span><span class="mord">0</span></span></span></span></p>
<p>와 같이 볼록성 조건을 요구하면 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>s</mi></mrow><annotation encoding="application/x-tex">s</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em"></span><span class="mord mathnormal">s</span></span></span></span>와 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>x</mi></mrow><annotation encoding="application/x-tex">x</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em"></span><span class="mord mathnormal">x</span></span></span></span>는 일대일 대응이 됩니다.</p>
<p>직관(기하학): 원함수 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>F</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">F(x)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.1389em">F</span><span class="mopen">(</span><span class="mord mathnormal">x</span><span class="mclose">)</span></span></span></span> 위의 한 점에서 접선을 그리면, 그 접선의 기울기가 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>s</mi></mrow><annotation encoding="application/x-tex">s</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em"></span><span class="mord mathnormal">s</span></span></span></span>입니다. 이 접선이 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>y</mi></mrow><annotation encoding="application/x-tex">y</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.1944em"></span><span class="mord mathnormal" style="margin-right:0.0359em">y</span></span></span></span>축(즉 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>x</mi><mo>=</mo><mn>0</mn></mrow><annotation encoding="application/x-tex">x=0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em"></span><span class="mord mathnormal">x</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:0.6444em"></span><span class="mord">0</span></span></span></span>)과 만나는 점을 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo>−</mo><mi>G</mi></mrow><annotation encoding="application/x-tex">-G</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.7667em;vertical-align:-0.0833em"></span><span class="mord">−</span><span class="mord mathnormal">G</span></span></span></span>라고 정의하면, 접선 방정식으로부터</p>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mfrac><mrow><mi>F</mi><mo>−</mo><mo stretchy="false">(</mo><mo>−</mo><mi>G</mi><mo stretchy="false">)</mo></mrow><mi>x</mi></mfrac><mo>=</mo><mi>s</mi></mrow><annotation encoding="application/x-tex">\frac{F - (-G)}{x} = s</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.355em;vertical-align:-0.345em"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.01em"><span style="top:-2.655em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">x</span></span></span></span><span style="top:-3.23em"><span class="pstrut" style="height:3em"></span><span class="frac-line" style="border-bottom-width:0.04em"></span></span><span style="top:-3.485em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.1389em">F</span><span class="mbin mtight">−</span><span class="mopen mtight">(</span><span class="mord mtight">−</span><span class="mord mathnormal mtight">G</span><span class="mclose mtight">)</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.345em"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:0.4306em"></span><span class="mord mathnormal">s</span></span></span></span></p>
<p>이 되어</p>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>G</mi><mo>=</mo><mi>s</mi><mi>x</mi><mo>−</mo><mi>F</mi></mrow><annotation encoding="application/x-tex">G = s x - F</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em"></span><span class="mord mathnormal">G</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:0.6667em;vertical-align:-0.0833em"></span><span class="mord mathnormal">s</span><span class="mord mathnormal">x</span><span class="mspace" style="margin-right:0.2222em"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em"></span></span><span class="base"><span class="strut" style="height:0.6833em"></span><span class="mord mathnormal" style="margin-right:0.1389em">F</span></span></span></span></p>
<p>를 얻습니다. 여기서 중요한 점은 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>x</mi></mrow><annotation encoding="application/x-tex">x</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em"></span><span class="mord mathnormal">x</span></span></span></span>가 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>s</mi></mrow><annotation encoding="application/x-tex">s</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em"></span><span class="mord mathnormal">s</span></span></span></span>의 함수로 바뀐 상황에서 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>G</mi></mrow><annotation encoding="application/x-tex">G</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em"></span><span class="mord mathnormal">G</span></span></span></span>를 정의한다면 정확히</p>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>G</mi><mo stretchy="false">(</mo><mi>s</mi><mo stretchy="false">)</mo><mo>=</mo><mi>s</mi><mtext> </mtext><mi>x</mi><mo stretchy="false">(</mo><mi>s</mi><mo stretchy="false">)</mo><mo>−</mo><mi>F</mi><mo fence="true" stretchy="true" minsize="1.2em" maxsize="1.2em">(</mo><mi>x</mi><mo stretchy="false">(</mo><mi>s</mi><mo stretchy="false">)</mo><mo fence="true" stretchy="true" minsize="1.2em" maxsize="1.2em">)</mo></mrow><annotation encoding="application/x-tex">G(s) = s\, x(s) - F\bigl(x(s)\bigr)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal">G</span><span class="mopen">(</span><span class="mord mathnormal">s</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal">s</span><span class="mspace" style="margin-right:0.1667em"></span><span class="mord mathnormal">x</span><span class="mopen">(</span><span class="mord mathnormal">s</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2222em"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em"></span></span><span class="base"><span class="strut" style="height:1.2em;vertical-align:-0.35em"></span><span class="mord mathnormal" style="margin-right:0.1389em">F</span><span class="mopen"><span class="delimsizing size1">(</span></span><span class="mord mathnormal">x</span><span class="mopen">(</span><span class="mord mathnormal">s</span><span class="mclose">)</span><span class="mclose"><span class="delimsizing size1">)</span></span></span></span></span></p>
<p>와 같이 쓸 수 있다는 것입니다. 이 표현은 단순한 대체가 아니라 '같은 정보의 재포장'입니다: 충분한 볼록성 조건이 있다면 다시 한 번 르장드르 변환을 적용해 원래로 되돌아갈 수 있습니다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 르장드르 변환</div><div class="admonitionContent_BuS1"><p>쉬운정의: 어떤 함수 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>F</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">F(x)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.1389em">F</span><span class="mopen">(</span><span class="mord mathnormal">x</span><span class="mclose">)</span></span></span></span>를 그 도함수 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>s</mi><mo>=</mo><mi>d</mi><mi>F</mi><mi mathvariant="normal">/</mi><mi>d</mi><mi>x</mi></mrow><annotation encoding="application/x-tex">s=dF/dx</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.4306em"></span><span class="mord mathnormal">s</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal">d</span><span class="mord mathnormal" style="margin-right:0.1389em">F</span><span class="mord">/</span><span class="mord mathnormal">d</span><span class="mord mathnormal">x</span></span></span></span>를 독립변수로 하는 새로운 함수 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>G</mi><mo stretchy="false">(</mo><mi>s</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">G(s)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal">G</span><span class="mopen">(</span><span class="mord mathnormal">s</span><span class="mclose">)</span></span></span></span>로 바꾸는 수학적 절차입니다.
예 everyday 예: 경사(가파름) 대신 '등고선에서의 기울기'로 지형을 설명하는 것과 비슷합니다. 지형의 높이 대신 특정 경사의 위치 정보를 중심으로 다시 기술하는 것이라 보시면 됩니다.</p></div></div>
<p>왜 이런 재표현이 유용한가? 다음과 같은 상황을 생각해보면 이해가 빠릅니다. 공학이나 실험에서 어떤 계에 걸리는 힘(force)을 직접 제어하거나 측정하기 쉽지만, 그에 대응하는 위치를 직접 다루기 어렵다면 힘을 독립변수로 사용하는 표현(예: 탄성계의 경우 퍼텐셜의 르장드르 변환)을 쓰는 것이 더 자연스럽습니다. 이 관점이 바로 열역학에서 '에너지 표현'과 '자유에너지 표현' 사이에 존재하는 실용적 이유와 직결됩니다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="2-조화-퍼텐셜예--변환이-실제로-무슨-정보를-보존소실하는가">2. 조화 퍼텐셜(예) — 변환이 실제로 무슨 정보를 보존/소실하는가<a href="https://ql.gl/ko/blog/3551c399/#2-%EC%A1%B0%ED%99%94-%ED%8D%BC%ED%85%90%EC%85%9C%EC%98%88--%EB%B3%80%ED%99%98%EC%9D%B4-%EC%8B%A4%EC%A0%9C%EB%A1%9C-%EB%AC%B4%EC%8A%A8-%EC%A0%95%EB%B3%B4%EB%A5%BC-%EB%B3%B4%EC%A1%B4%EC%86%8C%EC%8B%A4%ED%95%98%EB%8A%94%EA%B0%80" class="hash-link" aria-label="2. 조화 퍼텐셜(예) — 변환이 실제로 무슨 정보를 보존/소실하는가에 대한 직접 링크" title="2. 조화 퍼텐셜(예) — 변환이 실제로 무슨 정보를 보존/소실하는가에 대한 직접 링크" translate="no">​</a></h2>
<p>구체적인 예로 조화 퍼텐셜을 보겠습니다. 원래 퍼텐셜을</p>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>U</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mstyle scriptlevel="0" displaystyle="false"><mfrac><mn>1</mn><mn>2</mn></mfrac></mstyle><mi>k</mi><mo fence="true" stretchy="true" minsize="1.2em" maxsize="1.2em">(</mo><mi>x</mi><mo>−</mo><msub><mi>x</mi><mi>min</mi><mo>⁡</mo></msub><msup><mo fence="true" stretchy="true" minsize="1.2em" maxsize="1.2em">)</mo><mn>2</mn></msup></mrow><annotation encoding="application/x-tex">U(x) = \tfrac{1}{2}k\bigl(x - x_{\min}\bigr)^2</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.109em">U</span><span class="mopen">(</span><span class="mord mathnormal">x</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:1.2em;vertical-align:-0.35em"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.8451em"><span style="top:-2.655em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">2</span></span></span></span><span style="top:-3.23em"><span class="pstrut" style="height:3em"></span><span class="frac-line" style="border-bottom-width:0.04em"></span></span><span style="top:-3.394em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.345em"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mord mathnormal" style="margin-right:0.0315em">k</span><span class="mopen"><span class="delimsizing size1">(</span></span><span class="mord mathnormal">x</span><span class="mspace" style="margin-right:0.2222em"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em"></span></span><span class="base"><span class="strut" style="height:1.404em;vertical-align:-0.35em"></span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3175em"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em"><span class="pstrut" style="height:2.7em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mop mtight"><span class="mtight">m</span><span class="mtight">i</span><span class="mtight">n</span></span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em"><span></span></span></span></span></span></span><span class="mclose"><span class="mclose"><span class="delimsizing size1">)</span></span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:1.054em"><span style="top:-3.3029em;margin-right:0.05em"><span class="pstrut" style="height:2.7em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span></span></span></span></p>
<p>라 하고, 외부에서 힘 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>f</mi></mrow><annotation encoding="application/x-tex">f</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em"></span><span class="mord mathnormal" style="margin-right:0.1076em">f</span></span></span></span>를 걸면 평형 조건은 퍼텐셜에서 유도되는 내부 힘과 외부 힘의 합이 0이 되는 것입니다. 퍼텐셜에서 나오는 힘은 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo>−</mo><mi>d</mi><mi>U</mi><mi mathvariant="normal">/</mi><mi>d</mi><mi>x</mi></mrow><annotation encoding="application/x-tex">-dU/dx</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord">−</span><span class="mord mathnormal">d</span><span class="mord mathnormal" style="margin-right:0.109em">U</span><span class="mord">/</span><span class="mord mathnormal">d</span><span class="mord mathnormal">x</span></span></span></span>이므로 정적 평형은</p>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo>−</mo><mfrac><mrow><mi>d</mi><mi>U</mi></mrow><mrow><mi>d</mi><mi>x</mi></mrow></mfrac><mo>+</mo><mi>f</mi><mo>=</mo><mn>0</mn><mspace width="1em"></mspace><mo>⇒</mo><mspace width="1em"></mspace><mfrac><mrow><mi>d</mi><mi>U</mi></mrow><mrow><mi>d</mi><mi>x</mi></mrow></mfrac><mo>=</mo><mi>f</mi><mi mathvariant="normal">.</mi></mrow><annotation encoding="application/x-tex">-\frac{dU}{dx} + f = 0\quad\Rightarrow\quad \frac{dU}{dx} = f.</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.2251em;vertical-align:-0.345em"></span><span class="mord">−</span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.8801em"><span style="top:-2.655em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">d</span><span class="mord mathnormal mtight">x</span></span></span></span><span style="top:-3.23em"><span class="pstrut" style="height:3em"></span><span class="frac-line" style="border-bottom-width:0.04em"></span></span><span style="top:-3.394em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">d</span><span class="mord mathnormal mtight" style="margin-right:0.109em">U</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.345em"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mspace" style="margin-right:0.2222em"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em"></span></span><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em"></span><span class="mord mathnormal" style="margin-right:0.1076em">f</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:0.6444em"></span><span class="mord">0</span><span class="mspace" style="margin-right:1em"></span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">⇒</span><span class="mspace" style="margin-right:1em"></span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:1.2251em;vertical-align:-0.345em"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.8801em"><span style="top:-2.655em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">d</span><span class="mord mathnormal mtight">x</span></span></span></span><span style="top:-3.23em"><span class="pstrut" style="height:3em"></span><span class="frac-line" style="border-bottom-width:0.04em"></span></span><span style="top:-3.394em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">d</span><span class="mord mathnormal mtight" style="margin-right:0.109em">U</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.345em"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em"></span><span class="mord mathnormal" style="margin-right:0.1076em">f</span><span class="mord">.</span></span></span></span></p>
<p>이것을 풀면</p>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>x</mi><mo stretchy="false">(</mo><mi>f</mi><mo stretchy="false">)</mo><mo>=</mo><mfrac><mi>f</mi><mi>k</mi></mfrac><mo>+</mo><msub><mi>x</mi><mi>min</mi><mo>⁡</mo></msub><mi mathvariant="normal">.</mi></mrow><annotation encoding="application/x-tex">x(f) = \frac{f}{k} + x_{\min}.</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal">x</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.1076em">f</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:1.2772em;vertical-align:-0.345em"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.9322em"><span style="top:-2.655em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.0315em">k</span></span></span></span><span style="top:-3.23em"><span class="pstrut" style="height:3em"></span><span class="frac-line" style="border-bottom-width:0.04em"></span></span><span style="top:-3.4461em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.1076em">f</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.345em"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mspace" style="margin-right:0.2222em"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em"></span></span><span class="base"><span class="strut" style="height:0.5806em;vertical-align:-0.15em"></span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3175em"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em"><span class="pstrut" style="height:2.7em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mop mtight"><span class="mtight">m</span><span class="mtight">i</span><span class="mtight">n</span></span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em"><span></span></span></span></span></span></span><span class="mord">.</span></span></span></span></p>
<p>이제 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>U</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">U(x)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.109em">U</span><span class="mopen">(</span><span class="mord mathnormal">x</span><span class="mclose">)</span></span></span></span>의 르장드르 변환을 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>V</mi><mo stretchy="false">(</mo><mi>f</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">V(f)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.2222em">V</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.1076em">f</span><span class="mclose">)</span></span></span></span>라 하겠습니다. 정의에 따라</p>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>V</mi><mo stretchy="false">(</mo><mi>f</mi><mo stretchy="false">)</mo><mo>=</mo><mi>f</mi><mtext> </mtext><mi>x</mi><mo stretchy="false">(</mo><mi>f</mi><mo stretchy="false">)</mo><mo>−</mo><mi>U</mi><mo fence="true" stretchy="true" minsize="1.2em" maxsize="1.2em">(</mo><mi>x</mi><mo stretchy="false">(</mo><mi>f</mi><mo stretchy="false">)</mo><mo fence="true" stretchy="true" minsize="1.2em" maxsize="1.2em">)</mo><mi mathvariant="normal">.</mi></mrow><annotation encoding="application/x-tex">V(f) = f\, x(f) - U\bigl(x(f)\bigr).</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.2222em">V</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.1076em">f</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.1076em">f</span><span class="mspace" style="margin-right:0.1667em"></span><span class="mord mathnormal">x</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.1076em">f</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2222em"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em"></span></span><span class="base"><span class="strut" style="height:1.2em;vertical-align:-0.35em"></span><span class="mord mathnormal" style="margin-right:0.109em">U</span><span class="mopen"><span class="delimsizing size1">(</span></span><span class="mord mathnormal">x</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.1076em">f</span><span class="mclose">)</span><span class="mclose"><span class="delimsizing size1">)</span></span><span class="mord">.</span></span></span></span></p>
<p>직접 계산하면(간단한 대수적 정리)</p>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>V</mi><mo stretchy="false">(</mo><mi>f</mi><mo stretchy="false">)</mo><mo>=</mo><mfrac><mn>1</mn><mn>2</mn></mfrac><mfrac><msup><mi>f</mi><mn>2</mn></msup><mi>k</mi></mfrac><mo>+</mo><mi>f</mi><msub><mi>x</mi><mi>min</mi><mo>⁡</mo></msub><mi mathvariant="normal">.</mi></mrow><annotation encoding="application/x-tex">V(f) = \frac{1}{2}\frac{f^2}{k} + f x_{\min}.</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.2222em">V</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.1076em">f</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:1.415em;vertical-align:-0.345em"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.8451em"><span style="top:-2.655em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">2</span></span></span></span><span style="top:-3.23em"><span class="pstrut" style="height:3em"></span><span class="frac-line" style="border-bottom-width:0.04em"></span></span><span style="top:-3.394em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.345em"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.07em"><span style="top:-2.655em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.0315em">k</span></span></span></span><span style="top:-3.23em"><span class="pstrut" style="height:3em"></span><span class="frac-line" style="border-bottom-width:0.04em"></span></span><span style="top:-3.4461em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.1076em">f</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8913em"><span style="top:-2.931em;margin-right:0.0714em"><span class="pstrut" style="height:2.5em"></span><span class="sizing reset-size3 size1 mtight"><span class="mord mtight">2</span></span></span></span></span></span></span></span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.345em"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mspace" style="margin-right:0.2222em"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222em"></span></span><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em"></span><span class="mord mathnormal" style="margin-right:0.1076em">f</span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3175em"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em"><span class="pstrut" style="height:2.7em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mop mtight"><span class="mtight">m</span><span class="mtight">i</span><span class="mtight">n</span></span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em"><span></span></span></span></span></span></span><span class="mord">.</span></span></span></span></p>
<p>또한 변환 후에는</p>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>x</mi><mo stretchy="false">(</mo><mi>f</mi><mo stretchy="false">)</mo><mo>=</mo><mfrac><mrow><mi>d</mi><mi>V</mi></mrow><mrow><mi>d</mi><mi>f</mi></mrow></mfrac></mrow><annotation encoding="application/x-tex">x(f) = \frac{dV}{df}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal">x</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.1076em">f</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:1.3612em;vertical-align:-0.4811em"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.8801em"><span style="top:-2.655em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.1076em">df</span></span></span></span><span style="top:-3.23em"><span class="pstrut" style="height:3em"></span><span class="frac-line" style="border-bottom-width:0.04em"></span></span><span style="top:-3.394em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight">d</span><span class="mord mathnormal mtight" style="margin-right:0.2222em">V</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.4811em"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span></span></span></span></p>
<p>가 성립함을 확인할 수 있습니다. 이 예에서 중요한 관찰은 다음과 같습니다.</p>
<ul>
<li class="">르장드르 변환은 위치-기울기 쌍 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mi>x</mi><mo separator="true">,</mo><mi>s</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(x, s)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mopen">(</span><span class="mord mathnormal">x</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em"></span><span class="mord mathnormal">s</span><span class="mclose">)</span></span></span></span>을 기울기-위치 쌍 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="false">(</mo><mi>s</mi><mo separator="true">,</mo><mi>x</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">(s, x)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mopen">(</span><span class="mord mathnormal">s</span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.1667em"></span><span class="mord mathnormal">x</span><span class="mclose">)</span></span></span></span>로 재표현했다는 점에서 정보를 보존합니다. 변환을 두 번 하면 원래 함수로 돌아옵니다.</li>
<li class="">그러나 만약 단순히 원래 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>U</mi></mrow><annotation encoding="application/x-tex">U</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em"></span><span class="mord mathnormal" style="margin-right:0.109em">U</span></span></span></span>를 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>f</mi></mrow><annotation encoding="application/x-tex">f</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em"></span><span class="mord mathnormal" style="margin-right:0.1076em">f</span></span></span></span>에 대해 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>U</mi><mo stretchy="false">[</mo><mi>x</mi><mo stretchy="false">(</mo><mi>f</mi><mo stretchy="false">)</mo><mo stretchy="false">]</mo></mrow><annotation encoding="application/x-tex">U[x(f)]</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.109em">U</span><span class="mopen">[</span><span class="mord mathnormal">x</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.1076em">f</span><span class="mclose">)]</span></span></span></span> 형태로만 적는다면, 상수항 정보(여기서는 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>x</mi><mi>min</mi><mo>⁡</mo></msub></mrow><annotation encoding="application/x-tex">x_{\min}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.5806em;vertical-align:-0.15em"></span><span class="mord"><span class="mord mathnormal">x</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3175em"><span style="top:-2.55em;margin-left:0em;margin-right:0.05em"><span class="pstrut" style="height:2.7em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mop mtight"><span class="mtight">m</span><span class="mtight">i</span><span class="mtight">n</span></span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em"><span></span></span></span></span></span></span></span></span></span>)가 소실될 수 있습니다. 즉, 단순 치환과 '정식으로' 르장드르 변환을 취하는 것 사이에는 정보 보존성 측면에서 차이가 있습니다.</li>
</ul>
<p>이 예는 "왜 정확하게 정의된 변환을 써야 하는가"와 "어떤 정보가 변환 과정에서 보존되거나 제거되는가"를 명확히 보여줍니다. 현장에서 어떤 변수를 제어 가능한 매개변수로 취할지 결정할 때는 이 차이를 염두에 두어야 합니다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="3-라플라스-변환과-통계열역학적-연결--분배-함수로의-관점-전환">3. 라플라스 변환과 통계열역학적 연결 — 분배 함수로의 관점 전환<a href="https://ql.gl/ko/blog/3551c399/#3-%EB%9D%BC%ED%94%8C%EB%9D%BC%EC%8A%A4-%EB%B3%80%ED%99%98%EA%B3%BC-%ED%86%B5%EA%B3%84%EC%97%B4%EC%97%AD%ED%95%99%EC%A0%81-%EC%97%B0%EA%B2%B0--%EB%B6%84%EB%B0%B0-%ED%95%A8%EC%88%98%EB%A1%9C%EC%9D%98-%EA%B4%80%EC%A0%90-%EC%A0%84%ED%99%98" class="hash-link" aria-label="3. 라플라스 변환과 통계열역학적 연결 — 분배 함수로의 관점 전환에 대한 직접 링크" title="3. 라플라스 변환과 통계열역학적 연결 — 분배 함수로의 관점 전환에 대한 직접 링크" translate="no">​</a></h2>
<p>르장드르 변환과 직접적인 수학적 동일성은 없지만, 개념적으로 비슷한 역할을 하는 변환으로 라플라스 변환(Laplace transform)이 통계열역학에서 중요한 역할을 합니다. 미시상태 수밀도 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>W</mi><mo stretchy="false">(</mo><mi>U</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">W(U)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.1389em">W</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.109em">U</span><span class="mclose">)</span></span></span></span>(내부에너지가 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>U</mi></mrow><annotation encoding="application/x-tex">U</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em"></span><span class="mord mathnormal" style="margin-right:0.109em">U</span></span></span></span> 근처에 있는 상태들의 위상공간 부피)가 주어졌을 때 분배 함수(partition function)는</p>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>Z</mi><mo stretchy="false">(</mo><mi>β</mi><mo stretchy="false">)</mo><mo>=</mo><mo>∫</mo><mi>W</mi><mo stretchy="false">(</mo><mi>U</mi><mo stretchy="false">)</mo><mtext> </mtext><msup><mi>e</mi><mrow><mo>−</mo><mi>β</mi><mi>U</mi></mrow></msup><mtext> </mtext><mi>d</mi><mi>U</mi></mrow><annotation encoding="application/x-tex">Z(\beta) = \int W(U)\, e^{-\beta U} \, dU</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.0715em">Z</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0528em">β</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:1.1552em;vertical-align:-0.3061em"></span><span class="mop op-symbol small-op" style="margin-right:0.1945em;position:relative;top:-0.0006em">∫</span><span class="mspace" style="margin-right:0.1667em"></span><span class="mord mathnormal" style="margin-right:0.1389em">W</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.109em">U</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.1667em"></span><span class="mord"><span class="mord mathnormal">e</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8491em"><span style="top:-3.063em;margin-right:0.05em"><span class="pstrut" style="height:2.7em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">−</span><span class="mord mathnormal mtight" style="margin-right:0.0528em">β</span><span class="mord mathnormal mtight" style="margin-right:0.109em">U</span></span></span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em"></span><span class="mord mathnormal">d</span><span class="mord mathnormal" style="margin-right:0.109em">U</span></span></span></span></p>
<p>로 정의됩니다. 여기에서 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>β</mi><mo>=</mo><mo stretchy="false">(</mo><msub><mi>k</mi><mi>B</mi></msub><mi>T</mi><msup><mo stretchy="false">)</mo><mrow><mo>−</mo><mn>1</mn></mrow></msup></mrow><annotation encoding="application/x-tex">\beta = (k_B T)^{-1}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em"></span><span class="mord mathnormal" style="margin-right:0.0528em">β</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:1.0641em;vertical-align:-0.25em"></span><span class="mopen">(</span><span class="mord"><span class="mord mathnormal" style="margin-right:0.0315em">k</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.3283em"><span style="top:-2.55em;margin-left:-0.0315em;margin-right:0.05em"><span class="pstrut" style="height:2.7em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0502em">B</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.15em"><span></span></span></span></span></span></span><span class="mord mathnormal" style="margin-right:0.1389em">T</span><span class="mclose"><span class="mclose">)</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8141em"><span style="top:-3.063em;margin-right:0.05em"><span class="pstrut" style="height:2.7em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">−</span><span class="mord mtight">1</span></span></span></span></span></span></span></span></span></span></span></span>입니다. 분배 함수는 온도(혹은 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>β</mi></mrow><annotation encoding="application/x-tex">\beta</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em"></span><span class="mord mathnormal" style="margin-right:0.0528em">β</span></span></span></span>)를 독립변수로 하는 함수로, '에너지 대신 온도 관점'에서 계를 기술하는 도구입니다.</p>
<p>브롬위치 적분(Bromwich integral)을 이용하면 라플라스 변환의 역변환을 통해 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>W</mi><mo stretchy="false">(</mo><mi>U</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">W(U)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.1389em">W</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.109em">U</span><span class="mclose">)</span></span></span></span>를 다시 쓸 수 있습니다:</p>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>W</mi><mo stretchy="false">(</mo><mi>U</mi><mo stretchy="false">)</mo><mo>=</mo><mfrac><mn>1</mn><mrow><mn>2</mn><mi>π</mi><mi>i</mi></mrow></mfrac><msub><mo>∫</mo><mi>C</mi></msub><mi>Z</mi><mo stretchy="false">(</mo><mi>β</mi><mo stretchy="false">)</mo><mtext> </mtext><msup><mi>e</mi><mrow><mi>β</mi><mi>U</mi></mrow></msup><mtext> </mtext><mi>d</mi><mi>β</mi><mo separator="true">,</mo></mrow><annotation encoding="application/x-tex">W(U) = \frac{1}{2\pi i} \int_C Z(\beta)\, e^{\beta U} \, d\beta,</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.1389em">W</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.109em">U</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:1.2049em;vertical-align:-0.3558em"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.8451em"><span style="top:-2.655em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">2</span><span class="mord mathnormal mtight" style="margin-right:0.0359em">π</span><span class="mord mathnormal mtight">i</span></span></span></span><span style="top:-3.23em"><span class="pstrut" style="height:3em"></span><span class="frac-line" style="border-bottom-width:0.04em"></span></span><span style="top:-3.394em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.345em"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mspace" style="margin-right:0.1667em"></span><span class="mop"><span class="mop op-symbol small-op" style="margin-right:0.1945em;position:relative;top:-0.0006em">∫</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.1225em"><span style="top:-2.3442em;margin-left:-0.1945em;margin-right:0.05em"><span class="pstrut" style="height:2.7em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0715em">C</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.3558em"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em"></span><span class="mord mathnormal" style="margin-right:0.0715em">Z</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0528em">β</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.1667em"></span><span class="mord"><span class="mord mathnormal">e</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8491em"><span style="top:-3.063em;margin-right:0.05em"><span class="pstrut" style="height:2.7em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.0528em">β</span><span class="mord mathnormal mtight" style="margin-right:0.109em">U</span></span></span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em"></span><span class="mord mathnormal">d</span><span class="mord mathnormal" style="margin-right:0.0528em">β</span><span class="mpunct">,</span></span></span></span></p>
<p>여기서 경로 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>C</mi></mrow><annotation encoding="application/x-tex">C</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em"></span><span class="mord mathnormal" style="margin-right:0.0715em">C</span></span></span></span>는 적절하게 정한 복소평면상의 선입니다. 분배 함수는 또한 헬름홀츠 자유에너지 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>F</mi></mrow><annotation encoding="application/x-tex">F</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em"></span><span class="mord mathnormal" style="margin-right:0.1389em">F</span></span></span></span>와 연결되어, 보통 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi mathvariant="script">F</mi><mo>≡</mo><mi>β</mi><mi>F</mi></mrow><annotation encoding="application/x-tex">\mathcal{F} \equiv \beta F</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em"></span><span class="mord mathcal" style="margin-right:0.0993em">F</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">≡</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em"></span><span class="mord mathnormal" style="margin-right:0.0528em">β</span><span class="mord mathnormal" style="margin-right:0.1389em">F</span></span></span></span>로 정의하면 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>Z</mi><mo stretchy="false">(</mo><mi>β</mi><mo stretchy="false">)</mo><mo>=</mo><msup><mi>e</mi><mrow><mo>−</mo><mi mathvariant="script">F</mi><mo stretchy="false">(</mo><mi>β</mi><mo stretchy="false">)</mo></mrow></msup></mrow><annotation encoding="application/x-tex">Z(\beta) = e^{-\mathcal{F}(\beta)}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.0715em">Z</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0528em">β</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:0.888em"></span><span class="mord"><span class="mord mathnormal">e</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.888em"><span style="top:-3.063em;margin-right:0.05em"><span class="pstrut" style="height:2.7em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">−</span><span class="mord mathcal mtight" style="margin-right:0.0993em">F</span><span class="mopen mtight">(</span><span class="mord mathnormal mtight" style="margin-right:0.0528em">β</span><span class="mclose mtight">)</span></span></span></span></span></span></span></span></span></span></span></span>가 됩니다. 따라서 위 식은</p>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>W</mi><mo stretchy="false">(</mo><mi>U</mi><mo stretchy="false">)</mo><mo>=</mo><mfrac><mn>1</mn><mrow><mn>2</mn><mi>π</mi><mi>i</mi></mrow></mfrac><msub><mo>∫</mo><mi>C</mi></msub><msup><mi>e</mi><mrow><mo>−</mo><mi mathvariant="script">F</mi><mo stretchy="false">(</mo><mi>β</mi><mo stretchy="false">)</mo><mo>+</mo><mi>β</mi><mi>U</mi></mrow></msup><mtext> </mtext><mi>d</mi><mi>β</mi><mi mathvariant="normal">.</mi></mrow><annotation encoding="application/x-tex">W(U) = \frac{1}{2\pi i} \int_C e^{-\mathcal{F}(\beta) + \beta U}\, d\beta.</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.1389em">W</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.109em">U</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:1.2438em;vertical-align:-0.3558em"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.8451em"><span style="top:-2.655em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">2</span><span class="mord mathnormal mtight" style="margin-right:0.0359em">π</span><span class="mord mathnormal mtight">i</span></span></span></span><span style="top:-3.23em"><span class="pstrut" style="height:3em"></span><span class="frac-line" style="border-bottom-width:0.04em"></span></span><span style="top:-3.394em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.345em"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mspace" style="margin-right:0.1667em"></span><span class="mop"><span class="mop op-symbol small-op" style="margin-right:0.1945em;position:relative;top:-0.0006em">∫</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.1225em"><span style="top:-2.3442em;margin-left:-0.1945em;margin-right:0.05em"><span class="pstrut" style="height:2.7em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathnormal mtight" style="margin-right:0.0715em">C</span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.3558em"><span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em"></span><span class="mord"><span class="mord mathnormal">e</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.888em"><span style="top:-3.063em;margin-right:0.05em"><span class="pstrut" style="height:2.7em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">−</span><span class="mord mathcal mtight" style="margin-right:0.0993em">F</span><span class="mopen mtight">(</span><span class="mord mathnormal mtight" style="margin-right:0.0528em">β</span><span class="mclose mtight">)</span><span class="mbin mtight">+</span><span class="mord mathnormal mtight" style="margin-right:0.0528em">β</span><span class="mord mathnormal mtight" style="margin-right:0.109em">U</span></span></span></span></span></span></span></span></span><span class="mspace" style="margin-right:0.1667em"></span><span class="mord mathnormal">d</span><span class="mord mathnormal" style="margin-right:0.0528em">β</span><span class="mord">.</span></span></span></span></p>
<p>여기서 대규모 시스템(예: 입자 수 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>N</mi></mrow><annotation encoding="application/x-tex">N</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em"></span><span class="mord mathnormal" style="margin-right:0.109em">N</span></span></span></span>가 큰 계)을 생각하면 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi mathvariant="script">F</mi></mrow><annotation encoding="application/x-tex">\mathcal{F}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em"></span><span class="mord mathcal" style="margin-right:0.0993em">F</span></span></span></span>와 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>U</mi></mrow><annotation encoding="application/x-tex">U</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em"></span><span class="mord mathnormal" style="margin-right:0.109em">U</span></span></span></span>는 보통 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>O</mi><mo stretchy="false">(</mo><mi>N</mi><mo stretchy="false">)</mo></mrow><annotation encoding="application/x-tex">O(N)</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.0278em">O</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.109em">N</span><span class="mclose">)</span></span></span></span>으로 함께 커집니다. 이런 경우 위 적분은 '지수의 최대값 근처에서 지배된다'는 일반 원리를 따릅니다(안장점 근사 또는 라플라스의 방법). 즉, 적분은 다음 조건을 만족하는 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>β</mi></mrow><annotation encoding="application/x-tex">\beta</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em"></span><span class="mord mathnormal" style="margin-right:0.0528em">β</span></span></span></span> 근처에서 가장 크게 기여합니다:</p>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mfrac><mi mathvariant="normal">∂</mi><mrow><mi mathvariant="normal">∂</mi><mi>β</mi></mrow></mfrac><mo fence="true" stretchy="true" minsize="1.2em" maxsize="1.2em">(</mo><mi>β</mi><mi>U</mi><mo>−</mo><mi mathvariant="script">F</mi><mo stretchy="false">(</mo><mi>β</mi><mo stretchy="false">)</mo><mo fence="true" stretchy="true" minsize="1.2em" maxsize="1.2em">)</mo><mo>=</mo><mn>0</mn><mspace width="1em"></mspace><mo>⇒</mo><mspace width="1em"></mspace><mi>U</mi><mo>=</mo><mfrac><mrow><mi mathvariant="normal">∂</mi><mi mathvariant="script">F</mi></mrow><mrow><mi mathvariant="normal">∂</mi><mi>β</mi></mrow></mfrac><mi mathvariant="normal">.</mi></mrow><annotation encoding="application/x-tex">\frac{\partial}{\partial\beta}\bigl(\beta U - \mathcal{F}(\beta)\bigr) = 0 \quad\Rightarrow\quad U = \frac{\partial\mathcal{F}}{\partial\beta}.</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.3612em;vertical-align:-0.4811em"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.8801em"><span style="top:-2.655em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight" style="margin-right:0.0556em">∂</span><span class="mord mathnormal mtight" style="margin-right:0.0528em">β</span></span></span></span><span style="top:-3.23em"><span class="pstrut" style="height:3em"></span><span class="frac-line" style="border-bottom-width:0.04em"></span></span><span style="top:-3.394em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight" style="margin-right:0.0556em">∂</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.4811em"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mopen"><span class="delimsizing size1">(</span></span><span class="mord mathnormal" style="margin-right:0.0528em">β</span><span class="mord mathnormal" style="margin-right:0.109em">U</span><span class="mspace" style="margin-right:0.2222em"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em"></span></span><span class="base"><span class="strut" style="height:1.2em;vertical-align:-0.35em"></span><span class="mord mathcal" style="margin-right:0.0993em">F</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0528em">β</span><span class="mclose">)</span><span class="mclose"><span class="delimsizing size1">)</span></span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:0.6444em"></span><span class="mord">0</span><span class="mspace" style="margin-right:1em"></span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">⇒</span><span class="mspace" style="margin-right:1em"></span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:0.6833em"></span><span class="mord mathnormal" style="margin-right:0.109em">U</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:1.3612em;vertical-align:-0.4811em"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.8801em"><span style="top:-2.655em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight" style="margin-right:0.0556em">∂</span><span class="mord mathnormal mtight" style="margin-right:0.0528em">β</span></span></span></span><span style="top:-3.23em"><span class="pstrut" style="height:3em"></span><span class="frac-line" style="border-bottom-width:0.04em"></span></span><span style="top:-3.394em"><span class="pstrut" style="height:3em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight" style="margin-right:0.0556em">∂</span><span class="mord mathcal mtight" style="margin-right:0.0993em">F</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.4811em"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mord">.</span></span></span></span></p>
<p>결과적으로 지수항의 최대값을 사용하면</p>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>W</mi><mo stretchy="false">(</mo><mi>U</mi><mo stretchy="false">)</mo><mo>≈</mo><mi>exp</mi><mo>⁡</mo><mo fence="true" stretchy="true" minsize="1.2em" maxsize="1.2em">[</mo><mi>β</mi><mi>U</mi><mo>−</mo><mi mathvariant="script">F</mi><mo stretchy="false">(</mo><mi>β</mi><mo stretchy="false">)</mo><mo fence="true" stretchy="true" minsize="1.2em" maxsize="1.2em">]</mo><msub><mo fence="false" stretchy="true" minsize="1.2em" maxsize="1.2em">∣</mo><mrow><mi>β</mi><mo>=</mo><mi>β</mi><mo stretchy="false">(</mo><mi>U</mi><mo stretchy="false">)</mo></mrow></msub></mrow><annotation encoding="application/x-tex">W(U) \approx \exp\bigl[\beta U - \mathcal{F}(\beta)\bigr]\big|_{\beta=\beta(U)}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathnormal" style="margin-right:0.1389em">W</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.109em">U</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">≈</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:1.2em;vertical-align:-0.35em"></span><span class="mop">exp</span><span class="mopen"><span class="delimsizing size1">[</span></span><span class="mord mathnormal" style="margin-right:0.0528em">β</span><span class="mord mathnormal" style="margin-right:0.109em">U</span><span class="mspace" style="margin-right:0.2222em"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em"></span></span><span class="base"><span class="strut" style="height:1.4247em;vertical-align:-0.5747em"></span><span class="mord mathcal" style="margin-right:0.0993em">F</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0528em">β</span><span class="mclose">)</span><span class="mclose"><span class="delimsizing size1">]</span></span><span class="mord"><span class="mord"><span class="delimsizing mult"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.85em"><span style="top:-2.85em"><span class="pstrut" style="height:3.2em"></span><span style="width:0.333em;height:1.2em"><svg xmlns="http://www.w3.org/2000/svg" width="0.333em" height="1.2em" viewBox="0 0 333 1200"><path d="M145 15 v585 v0 v585 c2.667,10,9.667,15,21,15
c10,0,16.667,-5,20,-15 v-585 v0 v-585 c-2.667,-10,-9.667,-15,-21,-15
c-10,0,-16.667,5,-20,15z M188 15 H145 v585 v0 v585 h43z"></path></svg></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.35em"><span></span></span></span></span></span></span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.1253em"><span style="top:-2.3003em;margin-right:0.05em"><span class="pstrut" style="height:2.7em"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathnormal mtight" style="margin-right:0.0528em">β</span><span class="mrel mtight">=</span><span class="mord mathnormal mtight" style="margin-right:0.0528em">β</span><span class="mopen mtight">(</span><span class="mord mathnormal mtight" style="margin-right:0.109em">U</span><span class="mclose mtight">)</span></span></span></span></span><span class="vlist-s">​</span></span><span class="vlist-r"><span class="vlist" style="height:0.5747em"><span></span></span></span></span></span></span></span></span></span></p>
<p>이고 로그를 취하면(엔트로피 정의 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi mathvariant="script">S</mi><mo>=</mo><mi>ln</mi><mo>⁡</mo><mi>W</mi></mrow><annotation encoding="application/x-tex">\mathcal{S}=\ln W</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em"></span><span class="mord mathcal" style="margin-right:0.075em">S</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:0.6944em"></span><span class="mop">ln</span><span class="mspace" style="margin-right:0.1667em"></span><span class="mord mathnormal" style="margin-right:0.1389em">W</span></span></span></span>)</p>
<p><span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi mathvariant="script">F</mi><mo stretchy="false">(</mo><mi>β</mi><mo stretchy="false">)</mo><mo>=</mo><mi>β</mi><mi>U</mi><mo>−</mo><mi mathvariant="script">S</mi><mi mathvariant="normal">.</mi></mrow><annotation encoding="application/x-tex">\mathcal{F}(\beta) = \beta U - \mathcal{S}.</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em"></span><span class="mord mathcal" style="margin-right:0.0993em">F</span><span class="mopen">(</span><span class="mord mathnormal" style="margin-right:0.0528em">β</span><span class="mclose">)</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em"></span><span class="mord mathnormal" style="margin-right:0.0528em">β</span><span class="mord mathnormal" style="margin-right:0.109em">U</span><span class="mspace" style="margin-right:0.2222em"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em"></span></span><span class="base"><span class="strut" style="height:0.6833em"></span><span class="mord mathcal" style="margin-right:0.075em">S</span><span class="mord">.</span></span></span></span></p>
<p>이 식은 고전적인 관계 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>F</mi><mo>=</mo><mi>U</mi><mo>−</mo><mi>T</mi><mi>S</mi></mrow><annotation encoding="application/x-tex">F = U - T S</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em"></span><span class="mord mathnormal" style="margin-right:0.1389em">F</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:0.7667em;vertical-align:-0.0833em"></span><span class="mord mathnormal" style="margin-right:0.109em">U</span><span class="mspace" style="margin-right:0.2222em"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em"></span></span><span class="base"><span class="strut" style="height:0.6833em"></span><span class="mord mathnormal" style="margin-right:0.1389em">T</span><span class="mord mathnormal" style="margin-right:0.0576em">S</span></span></span></span>로 되돌아가며, 여기서 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi mathvariant="script">F</mi><mo>=</mo><mi>β</mi><mi>F</mi></mrow><annotation encoding="application/x-tex">\mathcal{F}=\beta F</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em"></span><span class="mord mathcal" style="margin-right:0.0993em">F</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em"></span><span class="mord mathnormal" style="margin-right:0.0528em">β</span><span class="mord mathnormal" style="margin-right:0.1389em">F</span></span></span></span>임을 기억해야 합니다. 요약하면, 라플라스/분배 함수 관점은 '에너지-고정(미시canonical) 설명'과 '온도-고정(열canonical) 설명' 사이를 연결하며, 큰 계에서는 안장점 근사로 두 표현이 서로 르장드르 변환처럼 쌍대적으로 연결된다고 볼 수 있습니다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 라플라스 변환</div><div class="admonitionContent_BuS1"><p>쉬운정의: 어떤 함수(예: 에너지 분포)를 지수 가중합(또는 적분)으로 변환하여 다른 변수(예: 역온도) 표현으로 바꾸는 연산입니다.
예 everyday 예: 시간-도메인에서의 신호를 주파수-도메인으로 바꾸는 과정(푸리에 변환과 유사한 맥락)과 비슷합니다. 한 종류의 정보를 다른 관점에서 보게 해 줍니다.</p></div></div>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 분배 함수(Partition function)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 주어진 역온도 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>β</mi></mrow><annotation encoding="application/x-tex">\beta</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8889em;vertical-align:-0.1944em"></span><span class="mord mathnormal" style="margin-right:0.0528em">β</span></span></span></span>에서 계가 가질 수 있는 모든 상태들의 가중합(정확히는 지수 가중 적분)으로, 온도 의존적 거시량을 계산하는 중심 도구입니다.
예 everyday 예: 식당의 메뉴별 주문 확률을 음식 가격(에너지)에 따라 가중합해서 전체 주문 패턴을 요약하는 지표를 만든다고 생각해 보세요. 분배 함수는 그 합계라고 볼 수 있습니다.</p></div></div>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 헬름홀츠 자유에너지</div><div class="admonitionContent_BuS1"><p>쉬운정의: 고정된 온도에서 계가 가질 수 있는 '일할 수 있는 에너지'의 척도로, 보통 <span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>F</mi><mo>=</mo><mi>U</mi><mo>−</mo><mi>T</mi><mi>S</mi></mrow><annotation encoding="application/x-tex">F = U - T S</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em"></span><span class="mord mathnormal" style="margin-right:0.1389em">F</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:0.7667em;vertical-align:-0.0833em"></span><span class="mord mathnormal" style="margin-right:0.109em">U</span><span class="mspace" style="margin-right:0.2222em"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em"></span></span><span class="base"><span class="strut" style="height:0.6833em"></span><span class="mord mathnormal" style="margin-right:0.1389em">T</span><span class="mord mathnormal" style="margin-right:0.0576em">S</span></span></span></span>로 정의됩니다.
예 everyday 예: 예산(자산)에서 필수비용(엔트로피로 표현되는 무질서 비용)을 빼면 실제로 사용할 수 있는 남는 돈을 얻는 것과 비슷합니다.</p></div></div>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="4-요약과-실무적-시사점">4. 요약과 실무적 시사점<a href="https://ql.gl/ko/blog/3551c399/#4-%EC%9A%94%EC%95%BD%EA%B3%BC-%EC%8B%A4%EB%AC%B4%EC%A0%81-%EC%8B%9C%EC%82%AC%EC%A0%90" class="hash-link" aria-label="4. 요약과 실무적 시사점에 대한 직접 링크" title="4. 요약과 실무적 시사점에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class="">르장드르 변환은 "변수의 관점을 바꾸되 정보는 잃지 않으려는" 경우의 표준 도구입니다. 기하학적으로는 '원함수의 접선 절편'을 취하는 과정으로 이해할 수 있습니다.</li>
<li class="">실제 물리 문제에서는 어떤 변수를 제어하는지가 중요하므로(예: 힘 대 위치, 온도 대 에너지) 적절한 쌍대 표현을 택하면 해석·계산이 쉬워집니다. 조화 퍼텐셜 예시는 이 점을 명확히 보여줍니다: 힘이 자연스러운 제어변수라면 퍼텐셜의 르장드르 변환을 사용하는 것이 더 편리합니다.</li>
<li class="">통계열역학에서는 라플라스 변환(분배 함수)이 미시상태 수밀도와 온도-표현을 연결하고, 큰 계에서는 안장점 근사를 통해 자유에너지와 엔트로피의 전형적 관계(<span class="katex"><span class="katex-mathml"><math xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>F</mi><mo>=</mo><mi>U</mi><mo>−</mo><mi>T</mi><mi>S</mi></mrow><annotation encoding="application/x-tex">F=U-TS</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.6833em"></span><span class="mord mathnormal" style="margin-right:0.1389em">F</span><span class="mspace" style="margin-right:0.2778em"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2778em"></span></span><span class="base"><span class="strut" style="height:0.7667em;vertical-align:-0.0833em"></span><span class="mord mathnormal" style="margin-right:0.109em">U</span><span class="mspace" style="margin-right:0.2222em"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222em"></span></span><span class="base"><span class="strut" style="height:0.6833em"></span><span class="mord mathnormal" style="margin-right:0.1389em">T</span><span class="mord mathnormal" style="margin-right:0.0576em">S</span></span></span></span>)를 얻습니다. 이 연결은 르장드르 변환과 '역할적으로' 닮아 있습니다: 서로 다른 변수의 관점에서 동일한 물리 정보를 기술하는 방식입니다.</li>
</ul>
<p>참고: 본 포스트는 statphys Dokuwiki의 "수학:르장드르_변환" 페이지(2026-02-06 수정)와 그 안의 예제, 그리고 거기 인용된 R. K. P. Zia 외(2009) 논문을 바탕으로 정리한 내용입니다. 원문은 교육적 요약 형태이며, 엄밀한 증명 세부는 해당 문헌과 교재를 참고하시기 바랍니다. 특히 브롬위치 적분과 안장점 근사 관련 엄밀 조건은 본 페이지의 요약문이 모두 다루지 않을 수 있으니 그 점은 원문과 추가 문헌을 확인하시길 권합니다.</p>
<p>참고자료:</p>
<ul>
<li class="">R. K. P. Zia, Edward F. Redish, and Susan R. McKay, "Making Sense of the Legendre Transform," Am. J. Phys. 77, 614 (2009), arXiv:0806.1147.</li>
<li class="">statphys Dokuwiki: 수학:르장드르_변환 (출처 페이지)</li>
</ul>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="sources">Sources<a href="https://ql.gl/ko/blog/3551c399/#sources" class="hash-link" aria-label="Sources에 대한 직접 링크" title="Sources에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class=""><a href="https://statphys.pknu.ac.kr/dokuwiki/doku.php?id=%EC%88%98%ED%95%99%3A%EB%A5%B4%EC%9E%A5%EB%93%9C%EB%A5%B4_%EB%B3%80%ED%99%98" target="_blank" rel="noopener noreferrer" class="">수학:르장드르_변환 (statphys Dokuwiki)</a> — license: <code>CC Attribution-Noncommercial-Share Alike 4.0 International</code>, retrieved: <code>2026-07-10</code>.</li>
<li class="">Image: <a href="https://ql.gl/ko/assets/files/cover-1ef0e95548d417e01a7aa73ac013c8cf.webp/" target="_blank" class="">AI-generated cover image via OpenRouter</a> — license: <code>ai-generated-original</code>.</li>
</ul>]]></content>
        <author>
            <name>p4r4d0xb0x</name>
            <uri>https://bdev.io</uri>
        </author>
        <category label="Research" term="Research"/>
        <category label="Explainer" term="Explainer"/>
        <category label="AI" term="AI"/>
    </entry>
    <entry>
        <title type="html"><![CDATA[Mathematics for Computer Science (MCS) — 구조와 핵심 개념 분석]]></title>
        <id>https://ql.gl/ko/blog/0667fd2f/</id>
        <link href="https://ql.gl/ko/blog/0667fd2f/"/>
        <updated>2026-07-07T00:00:00.000Z</updated>
        <summary type="html"><![CDATA[MIT 강의노트 'Mathematics for Computer Science' (Lehman, Leighton, Meyer, 2018)을 근거로, 교재의 목적, 핵심 개념(증명법·공리·귀납 등), 구성 방식과 논리 전개를 분석합니다. 증거팩의 목차와 발췌를 바탕으로 불확실성을 명시하고 요약합니다.]]></summary>
        <content type="html"><![CDATA[
<p><img decoding="async" loading="lazy" src="https://ql.gl/ko/assets/images/cover-f23e4fe9b239649776aff5dfe9308045.webp" width="1200" height="670" class="img_ev3q"></p>
<p>이 글은 MIT 강의노트 "Mathematics for Computer Science"(Lehman, Leighton, Meyer, 2018)의 공개 PDF에서 발췌한 증거팩을 바탕으로, 교재의 목적과 핵심 개념을 기술적·학문적 관점에서 정리한 것입니다. 본 분석은 제공된 목차와 주요 발췌(서문, 1장 일부, 목차 전반)를 근거로 하며, 원문 전체를 대조해 확인하지 못한 세부사항은 불확실성으로 명시합니다.</p>
<p>요약: 교재는 컴퓨터과학 문제를 수학적 모델과 증명 방법으로 분석하는 것을 목적으로 하며(본문: "This text explains how to use mathematical models and methods to analyze problems that arise in computer science"), 증명(proofs)과 귀납(induction), 공리적 방법(ax- iomatic method) 등 기초적 기법을 중심으로 체계적으로 전개됩니다. 목차는 크게 I. Proofs, II. Structures, III. Counting, IV. Probability, V. Recurrences 등으로 구성되어 있어 '기초 → 자료구조·구성 → 응용(확률·점화)'의 흐름을 보입니다.</p>
<p>주요 근거 인용(발췌 기반): 교재 서문과 목차 발췌에서 "Proofs play a central role" 등 문장이 제공되어 있으며, Part I에서 증명법(Well Ordering Principle, Induction 등), Part IV에서 확률의 네 단계 방법(The Four-Step Method) 같은 실용적 기법이 차례로 소개됩니다.</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 증명 (proof)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 어떤 수학적 주장(proposition)이 참임을 논리적 단계로 차근차근 보이는 과정입니다.
일상 예: 계약서에서 두 사람의 합의 내용을 근거 문서로 차례로 설명해 결론을 도출하는 과정과 비슷합니다.</p></div></div>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 공리 (axiom)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 더 이상 증명 없이 받아들이는 기본 전제나 원리로, 그 위에 다른 명제를 쌓아 증명합니다.
일상 예: 놀이 규칙을 정할 때 "주사위는 여섯 면을 가진다"를 처음부터 인정하는 것과 같습니다.</p></div></div>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 귀납법 (induction)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 자연수 등 반복되는 구조에 대해 기초 사례(base case)를 보이고, 임의의 단계에서 다음 단계가 성립함을 보아 모든 단계에 대해 성립함을 증명하는 방법입니다.
일상 예: 계단을 오르는 방법을 설명할 때 "첫 계단을 오를 수 있고, 임의의 계단을 오를 수 있으면 다음 계단도 오른다"고 하면 모든 계단을 오를 수 있다고 결론내리는 것과 유사합니다.</p></div></div>
<p>주요 관찰 (제공된 증거에 기초)</p>
<ul>
<li class="">
<p>교재의 목적과 범위: 서문에서 명시된 바와 목차 구성으로 볼 때, 목표는 컴퓨터과학에서 자주 마주치는 명제들을 수학적으로 정형화하고, 증명 기법을 실무(프로그램·시스템 검증)에 적용할 수 있게 하는 것입니다. (발췌: "Proofs play a central role" / "use mathematical models and methods to analyze problems that arise in computer science").</p>
</li>
<li class="">
<p>체계적 전개: 목차(증거팩 발췌)는 Part I에서 증명과 논리(Chapters 1–8), Part II에서 수론·그래프 등의 구조(Chapters 9–13), Part III에서 조합(counting), Part IV에서 확률(Chapters 17–21), Part V에서 점화식(Recurrences)로 이어지며, 기초 이론 → 자료형·구조 → 계산·확률·점화의 점진적 심화가 분명합니다.</p>
</li>
<li class="">
<p>실용성과 이론의 병행: 서문과 1장의 발췌는 이론적 엄밀성(공리·증명)과 함께 프로그램·하드웨어 검증 같은 실무적 응용을 강조합니다(예: CPU 칩 검증 사례 언급). 이는 교재가 단순한 수학 이론서가 아니라 CS 응용을 겨냥한 강의노트임을 시사합니다.</p>
</li>
</ul>
<p>불확실성 표기: 제공된 증거는 방대한 전체 PDF에서 일부(서문, 1장, 목차 일부)만을 포함합니다. 따라서 개별 장의 상세 증명·예제·연습문제 수준의 구체적 배치나 최신 개정 세부사항은 증거팩에 나타나지 않을 수 있습니다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="논문-구조-분석">논문 구조 분석<a href="https://ql.gl/ko/blog/0667fd2f/#%EB%85%BC%EB%AC%B8-%EA%B5%AC%EC%A1%B0-%EB%B6%84%EC%84%9D" class="hash-link" aria-label="논문 구조 분석에 대한 직접 링크" title="논문 구조 분석에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class="">
<p>IMRaD 판별 — 이 문서는 전형적인 IMRaD(Introduction, Methods, Results, Discussion) 연구 논문 구조를 따르지 않습니다. 검출된 구조 정보에 따르면 "Introduction"과 "Methods" 성격의 섹션(증명 기법, 수학적 방법)이 명확히 존재하며, 일부는 'Results'로 볼 수 있는 응용 예제나 결과적 정리(예: 정리, 응용 문제)가 포함됩니다. 그러나 "Discussion"에 해당하는 별도 종합·비교·한계 논의 섹션은 증거팩에서 검출되지 않았고, 전체적으로는 교재 특유의 파트별(Proofs, Structures, Counting, Probability, Recurrences) 구성이라는 점에서 IMRaD가 완전하게 적용되지는 않습니다. 요약하면: Introduction — 있음; Methods — 있음(다수의 장에 걸친 증명기법); Results — 부분적(응용·예제); Discussion — 명확한 별도 섹션 없음.</p>
</li>
<li class="">
<p>Logical Flow / 큰그림 → 작은그림 — 이 교재는 "기초적 개념 확립 → 기법 도입 → 응용·특수 주제"의 일반→특수 흐름으로 조직됩니다. 구체적으로는: 1장(증명, 공리·명제)과 2장(Well Ordering)·5장(Induction) 등에서 사고 도구와 기법을 먼저 도입하고, 그 위에 3장(논리식), 4장(자료형) 등이 쌓입니다. 이어 Part II(Structures)는 수론·그래프 등 기본 구조를 다루고, Part III~V에서는 조합·확률·점화와 같은 응용 영역으로 확장됩니다. 각 장은 이전 장에서 도입된 정의와 기법을 전제로 하여 점진적으로 복잡도를 높이며, 이로 인해 학습자가 체계적으로 문제 해결 역량을 키울 수 있도록 설계되어 있습니다. 목차 발췌에서 보여지는 챕터 순서(예: 증명법 → 수학적 자료형 → 귀납과 상태기계 → 재귀적 자료형 → 무한집합 → 수론·그래프 → 조합 → 확률 → 점화)는 바로 이 점진적 설계의 증거입니다.</p>
</li>
</ul>
<p>마지막으로, 교재는 연구 논문이라기보다는 강의노트/교과서 형식에 가까우므로, 독자에게는 '방법론(증명기술) 학습'과 '응용(검증·알고리즘 분석)'의 두 축을 연결해 주는 교육용 논리 흐름으로 읽히는 것이 합리적입니다.</p>
<p>Sources</p>
<ul>
<li class="">원본: Eric Lehman, F. Thomson Leighton, Albert R. Meyer, "Mathematics for Computer Science", revised 2018. 공개 PDF: <a href="https://courses.csail.mit.edu/6.042/spring18/mcs.pdf" target="_blank" rel="noopener noreferrer" class="">https://courses.csail.mit.edu/6.042/spring18/mcs.pdf</a> (Creative Commons Attribution-ShareAlike 3.0). 본 게시물은 제공된 증거팩(목차 및 발췌)을 바탕으로 요약·분석하였으며, 전체 원문과의 상세 불일치 가능성이 있습니다.</li>
</ul>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="sources">Sources<a href="https://ql.gl/ko/blog/0667fd2f/#sources" class="hash-link" aria-label="Sources에 대한 직접 링크" title="Sources에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class=""><a href="https://courses.csail.mit.edu/6.042/spring18/mcs.pdf" target="_blank" rel="noopener noreferrer" class="">Mathematics for Computer Science — MIT course notes (Eric Lehman, Tom Leighton, Albert R. Meyer, 2018)</a> — license: <code>CreativeCommons-Attribution-ShareAlike-3.0</code>, retrieved: <code>2026-07-07</code>.</li>
<li class="">Image: <a href="https://ql.gl/ko/assets/files/cover-f23e4fe9b239649776aff5dfe9308045.webp/" target="_blank" class="">AI-generated cover image via OpenRouter</a> — license: <code>ai-generated-original</code>.</li>
</ul>]]></content>
        <author>
            <name>p4r4d0xb0x</name>
            <uri>https://bdev.io</uri>
        </author>
        <category label="Research" term="Research"/>
        <category label="TIL" term="TIL"/>
        <category label="AI" term="AI"/>
        <category label="Explainer" term="Explainer"/>
    </entry>
    <entry>
        <title type="html"><![CDATA[Textbooks Are All You Need — 고품질 교재 데이터로 작은 코드 LLM 성능 끌어올리기]]></title>
        <id>https://ql.gl/ko/blog/a3babb9c/</id>
        <link href="https://ql.gl/ko/blog/a3babb9c/"/>
        <updated>2026-07-07T00:00:00.000Z</updated>
        <summary type="html"><![CDATA[Microsoft Research의 'Textbooks Are All You Need' 논문 요약과 분석. 1.3B 파라미터 코드 LLM(phi-1)이 '교재 품질' 데이터와 소규모 합성 연습 데이터로 HumanEval/MBPP 성능을 크게 향상시킨 방법과 한계 검토.]]></summary>
        <content type="html"><![CDATA[<p><img decoding="async" loading="lazy" src="https://ql.gl/ko/assets/images/cover-e4993ec4e96756fd97e311571d816738.webp" width="1200" height="670" class="img_ev3q"></p>
<p>Microsoft Research의 'Textbooks Are All You Need'는 소형 코드 전용 LLM인 phi-1(1.3B 파라미터)을 중심으로, 대규모 모델·데이터 스케일 대신 '교재 품질(textbook-quality)'의 선별된 데이터와 소규모 합성 연습 데이터로도 우수한 코드 생성 성능을 달성할 수 있음을 실험으로 보여준다. 주요 결과(논문 초록과 본문 요약에 근거): phi-1은 1.3B 파라미터 모델로 HumanEval에서 50.6% pass@1, MBPP에서 55.5%를 보고하며, 사전학습용으로 약 6B 토큰(웹 필터링)과 1B 토큰 미만(합성 교재), 미세조정에 약 180M 토큰을 사용했다는 점이 핵심이다.</p>
<!-- -->
<p>본 포스트는 논문 초록과 주요 섹션(선별된 청크와 인용문)에 근거해 요약·분석한다. 원문은 일부 합성 데이터 생성 세부사항을 공개하지 않아 재현성에 제약이 있음을 저자 스스로 언급한다; 따라서 아래 분석은 제공된 증거 팩(evidence pack)과 감지된 구조에 기반한 해석임을 명시한다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="핵심-요지-요약">핵심 요지 요약<a href="https://ql.gl/ko/blog/a3babb9c/#%ED%95%B5%EC%8B%AC-%EC%9A%94%EC%A7%80-%EC%9A%94%EC%95%BD" class="hash-link" aria-label="핵심 요지 요약에 대한 직접 링크" title="핵심 요지 요약에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class="">목표: 모델·컴퓨트 스케일을 크게 늘리지 않고도, 고품질 데이터 선별과 소규모 합성 연습 데이터로 코드 생성 성능을 향상.</li>
<li class="">데이터 구성: (1) 필터링된 코드-언어 코퍼스(The Stack, StackOverflow 일부 필터) 약 6B 토큰, (2) GPT-3.5로 합성한 교재형 텍스트 1B 토큰 미만, (3) 약 180M 토큰의 합성 연습문제(CodeExercises)로 구성된 파이프라인.</li>
<li class="">결과 요약: phi-1(1.3B, 약 50B 토큰 관찰 포함) — HumanEval pass@1 50.6%, MBPP 55.5%. phi-1-base(사전학습만)도 29% 성능을 보였고, phi-1-small(350M)도 약 45%를 보고해 데이터 품질의 영향력을 강조.</li>
<li class="">방법적 특징: 모델 아키텍처는 비교적 표준적(decoder-only Transformer, FlashAttention 등). 저자들은 성능 향상의 주된 원인을 데이터 선별 및 합성 교재/연습의 조합으로 본다.</li>
</ul>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: HumanEval</div><div class="admonitionContent_BuS1"><p>쉬운정의: HumanEval은 함수 설명(docstring) 기반의 파이썬 프로그래밍 문제로 LLM의 코드 생성 능력을 평가하는 벤치마크입니다.
일상 예: 코딩 테스트에서 주어진 함수 설명을 보고 그 함수를 완성하는 과제와 유사합니다.</p></div></div>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: pass@1</div><div class="admonitionContent_BuS1"><p>쉬운정의: 주어진 생성 시도 중 모델이 올바른(통과하는) 답안을 단 한 번의 시도에서 생성할 확률을 측정한 지표입니다.
일상 예: 한 번의 제출로 정답을 맞추는 코딩테스트의 합격률이라고 보면 됩니다.</p></div></div>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: scaling laws</div><div class="admonitionContent_BuS1"><p>쉬운정의: 모델 크기(파라미터), 데이터 양, 연산량 등 자원을 늘릴 때 모델 성능이 얼마나 개선되는지 경험적으로 관찰한 관계입니다.
일상 예: 공부시간을 늘리면 점수가 오르는 경향이 있지만, 그 비율이 일정하지 않은 것과 비슷합니다.</p></div></div>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: finetuning (미세조정)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 사전학습된 모델을 특정 목적(예: 문제 유형)에 맞춘 작은 데이터셋으로 추가 학습시켜 성능을 개선하는 과정입니다.
일상 예: 일반 영어 실력을 가진 사람을 인터뷰 준비용 모의면접으로 훈련시키는 것과 유사합니다.</p></div></div>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: emergent properties (돌발적 능력)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 모델 규모나 학습 절차 변경 이후 기존에는 보이지 않던 새로운 능력이나 성질이 갑자기 나타나는 현상입니다.
일상 예: 친구가 어느 날부터 갑자기 특정 분야에 대한 이해가 확 좋아진 것처럼 보이는 현상과 유사합니다.</p></div></div>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="데이터-설계와-실험적-근거">데이터 설계와 실험적 근거<a href="https://ql.gl/ko/blog/a3babb9c/#%EB%8D%B0%EC%9D%B4%ED%84%B0-%EC%84%A4%EA%B3%84%EC%99%80-%EC%8B%A4%ED%97%98%EC%A0%81-%EA%B7%BC%EA%B1%B0" class="hash-link" aria-label="데이터 설계와 실험적 근거에 대한 직접 링크" title="데이터 설계와 실험적 근거에 대한 직접 링크" translate="no">​</a></h2>
<p>논문의 핵심 주장은 "데이터 품질(textbook-quality)을 고도화하면 훨씬 작은 모델과 적은 토큰으로도 높은 성능을 얻을 수 있다"는 점이다. 증거로 제시된 요소는 다음과 같다.</p>
<ul>
<li class="">필터링: The Stack 등 대규모 코드 코퍼스에서 교육적 가치가 높은 샘플만 선별하기 위해 GPT-4로 100k 샘플을 주석(annotate)하고, 코드 임베딩 기반 랜덤포레스트 분류기를 학습해 대규모 샘플을 필터했다는 점(Chunk 3).</li>
<li class="">합성 교재: GPT-3.5를 이용해 파이썬 교재(예제·설명 포함)를 합성해 1B 토큰 미만을 확보했고, 주제·대상 제한을 통해 사고력·알고리즘적 사고를 촉진하도록 유도했다(Chunk 5).</li>
<li class="">합성 연습 데이터: docstring 완성 형태의 연습문제 약 180M 토큰으로 finetuning을 수행하자 HumanEval 성능이 크게 향상되었다는 실험적 관찰(Chunks 2, 5, 6).</li>
</ul>
<p>원문은 필터링 자체가 필수적이라는 실험 증거(예: 동일한 훈련 스텝에서 필터된 데이터가 더 높은 HumanEval 성능을 보였음)를 제시하고, 작은 모델·적은 토큰으로도 경쟁력 있는 성능을 달성했다고 보고한다(Chunk 4의 수치 인용). 다만 합성 데이터 생성의 세부 프롬프트/파라미터 일부는 공개하지 않았다고 명시되어 있어 재현에는 한계가 있다(evidence quote: "we omit some details of the synthetic data generation, for proprietary reasons").</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="구현-세부-아키텍처와-학습">구현 세부: 아키텍처와 학습<a href="https://ql.gl/ko/blog/a3babb9c/#%EA%B5%AC%ED%98%84-%EC%84%B8%EB%B6%80-%EC%95%84%ED%82%A4%ED%85%8D%EC%B2%98%EC%99%80-%ED%95%99%EC%8A%B5" class="hash-link" aria-label="구현 세부: 아키텍처와 학습에 대한 직접 링크" title="구현 세부: 아키텍처와 학습에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class="">아키텍처: decoder-only Transformer, FlashAttention, 병렬 MHA+MLP 구성, rotary position embeddings 등 표준 기법 채택(Chunk 6).</li>
<li class="">학습: 시퀀스 길이 2048, fp16, AdamW, linear-warmup-linear-decay 등. phi-1-base는 약 36k 스텝(약 50B 토큰 관찰에 해당)으로 29% HumanEval을 달성했고, 이후 CodeExercises로 finetune해 최종 50% 이상을 얻음(Chunk 6).</li>
</ul>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="한계와-불확실성">한계와 불확실성<a href="https://ql.gl/ko/blog/a3babb9c/#%ED%95%9C%EA%B3%84%EC%99%80-%EB%B6%88%ED%99%95%EC%8B%A4%EC%84%B1" class="hash-link" aria-label="한계와 불확실성에 대한 직접 링크" title="한계와 불확실성에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class="">합성 데이터의 민감한 세부사항(프롬프트, 필터링 기준 일부)은 공개되지 않아 완전한 재현이 어렵다(논문 본문도 이를 인정).</li>
<li class="">논문은 코드 생성(주로 짧은 파이썬 함수)이라는 좁은 과제에 초점을 맞춘다; 일반 자연어 이해나 더 복잡한 소프트웨어 공학 과제에의 일반화는 추가 검증이 필요하다.</li>
<li class="">문서에서 '오른쪽' 벤치마크(예: HumanEval)와의 오염(contamination) 여부를 별도 섹션에서 논의하나, 제공된 증거 팩은 일부 분석 결과만 포함하고 있어 완전한 판단에는 원문 전체 확인이 필요하다(evidence quote: "we study possible contamination ...").</li>
</ul>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="논문-구조-분석">논문 구조 분석<a href="https://ql.gl/ko/blog/a3babb9c/#%EB%85%BC%EB%AC%B8-%EA%B5%AC%EC%A1%B0-%EB%B6%84%EC%84%9D" class="hash-link" aria-label="논문 구조 분석에 대한 직접 링크" title="논문 구조 분석에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class="">
<p>IMRaD 판별: 감지된 구조(detected_headings)와 제공된 청크에 따르면 이 논문은 전형적인 IMRaD의 핵심 부분을 갖추되 완전하지는 않다. 구체적으로:</p>
<ul>
<li class="">Introduction: 존재(1 Introduction) — 문제 제기와 동기(데이터 품질의 중요성, scaling laws 관련 논의).</li>
<li class="">Methods(또는 Materials &amp; Methods): 존재(Section 2: Training details and the importance of high-quality data) — 데이터 선별, 합성 데이터 생성, 모델 아키텍처와 학습 설정을 설명.</li>
<li class="">Results: 존재(Section 3: emergent properties 및 Figure 2.1과 성능표) — HumanEval/MBPP 성능 및 필터링·finetuning의 영향 보고.</li>
<li class="">Discussion: 명시적 제목의 Discussion 섹션은 감지되지 않았고, 일부 논의(대안 벤치마크, 오염 검사 등)가 별도의 섹션(Section 4, 5)으로 분산되어 있다. 따라서 IMRaD가 부분적으로 충족되지만 "완전한" Discussion 블록은 분리되어 있지 않거나 결과와 혼합되어 있다.</li>
</ul>
</li>
<li class="">
<p>논리 흐름(큰그림 → 작은그림): 논문은 문제→갭→기여(problem→gap→contribution) 형태로 구성되어 논리적 일관성이 있다. 구체적 단계는 다음과 같다:</p>
<ol>
<li class="">큰그림(Introduction): Transformer와 스케일(Scaling laws)에 의한 성능 개선의 관행을 제시하고, 데이터 품질이라는 대체 축을 제시하며 연구동기를 만든다(Chunk 1의 인용).</li>
<li class="">방법(Methods): 왜 기존 코드 데이터셋이 교육적 측면에서 부족한지(비자립적 스니펫, 보일러플레이트 등)를 진단하고, 필터링 절차와 합성 교재·연습 데이터 설계(데이터셋 구성과 다양성 유도 기법)를 제시한다(Chunks 3–5).</li>
<li class="">결과(Results): 선별된 데이터와 소규모 finetuning이 HumanEval/MBPP 성능을 어떻게 크게 향상시켰는지를 수치와 도표로 제시한다(Chunk 2, Figure 2.1).</li>
<li class="">후속 논의/검증(Sections 4–5): 벤치마크 대안, 오염(contamination) 검토, 공개 범위(합성 데이터의 일부 비공개) 등을 논의하며 연구의 한계와 향후 방향을 제시한다(증거 인용).</li>
</ol>
<p>이 구조는 '문제 제기 → 데이터 중심 솔루션 제안 → 실험 증거 제시 → 한계/추가 검증'으로 자연스럽게 이어지며, 각 섹션이 이전 섹션에서 소개한 가설(데이터 품질이 성능을 바꾼다)을 점진적으로 검증하는 방식으로 조직되어 있다. 다만 Discussion이 분리된 장으로 명확히 드러나지 않고 결과와 논의가 일부 혼합된 점은 감지된 구조에서 확인된다.</p>
</li>
</ul>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="실무적-시사점">실무적 시사점<a href="https://ql.gl/ko/blog/a3babb9c/#%EC%8B%A4%EB%AC%B4%EC%A0%81-%EC%8B%9C%EC%82%AC%EC%A0%90" class="hash-link" aria-label="실무적 시사점에 대한 직접 링크" title="실무적 시사점에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class="">데이터 공학 우선: 코드 LLM을 구축할 때 데이터 선별·합성 전략은 모델·컴퓨팅 예산을 줄이면서도 큰 효과를 낼 수 있다.</li>
<li class="">작은 모델도 실전적 성능 가능: 적절히 설계된 데이터와 finetuning으로 1.3B급 모델이 널리 쓰이는 벤치마크에서 경쟁력 있는 성능을 낼 수 있다.</li>
<li class="">재현성 주의: 합성 데이터 생성의 비공개 요소와 오염 가능성 등은 실무 적용 시 확인·대응해야 할 리스크다.</li>
</ul>
<p>Sources</p>
<ul>
<li class="">원문: Suriya Gunasekar et al., "Textbooks Are All You Need", Microsoft Research (arXiv preprint). 원문 PDF: <a href="https://arxiv.org/pdf/2306.11644" target="_blank" rel="noopener noreferrer" class="">https://arxiv.org/pdf/2306.11644</a></li>
</ul>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="sources">Sources<a href="https://ql.gl/ko/blog/a3babb9c/#sources" class="hash-link" aria-label="Sources에 대한 직접 링크" title="Sources에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class=""><a href="https://arxiv.org/pdf/2306.11644" target="_blank" rel="noopener noreferrer" class="">Textbooks Are All You Need</a> — license: <code>unknown</code>, retrieved: <code>2026-07-07</code>.</li>
<li class="">Image: <a href="https://ql.gl/ko/assets/files/cover-e4993ec4e96756fd97e311571d816738.webp/" target="_blank" class="">AI-generated cover image via OpenRouter</a> — license: <code>ai-generated-original</code>.</li>
</ul>]]></content>
        <author>
            <name>p4r4d0xb0x</name>
            <uri>https://bdev.io</uri>
        </author>
        <category label="Research" term="Research"/>
        <category label="LLM" term="LLM"/>
        <category label="AI" term="AI"/>
        <category label="Explainer" term="Explainer"/>
    </entry>
    <entry>
        <title type="html"><![CDATA[AgentsCAD: FDM 부품용 자동 제조 설계 — 다중 에이전트 LLM 추론과 기하학적 특징 인식]]></title>
        <id>https://ql.gl/ko/blog/01427437/</id>
        <link href="https://ql.gl/ko/blog/01427437/"/>
        <updated>2026-07-06T00:00:00.000Z</updated>
        <summary type="html"><![CDATA[AgentsCAD(논문 요약): STEP B-Rep 파싱, 과대격차(overhang) 감지, GraphSAGE 기반 의미 레이블 주입, 다중 에이전트 LLM 추론(Claude Sonnet) 및 GPT-4o 시각검증을 결합해 FDM용 설계-제조(DFAM) 수정을 자동화하는 연구를 기술적으로 검토합니다. 증거가 제한적일 때의 불확실성도 명시합니다.]]></summary>
        <content type="html"><![CDATA[<p><img decoding="async" loading="lazy" src="https://ql.gl/ko/assets/images/cover-c66011d47ed25a8a8fa13763654cd328.webp" width="1200" height="675" class="img_ev3q"></p>
<p>AgentsCAD는 Fused Deposition Modeling(FDM) 부품의 설계-제조(DFAM) 요구를 자동으로 진단하고 수정 제안을 생성하기 위해 기하학적 특징 인식과 다중 에이전트 LLM(reasoning agents)을 결합한 파이프라인을 제안합니다. 본 포스트는 arXiv의 초록 및 공개 메타데이터를 바탕으로 시스템 구조, 핵심 기법, 적용 사례(논문에 기재된 birdhouse 예제)를 기술적으로 요약하고, 제공된 증거에서 확인되지 않는 세부사항은 명확히 표기합니다.</p>
<!-- -->
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="요약--논문에서-보고된-핵심-구성요소">요약 — 논문에서 보고된 핵심 구성요소<a href="https://ql.gl/ko/blog/01427437/#%EC%9A%94%EC%95%BD--%EB%85%BC%EB%AC%B8%EC%97%90%EC%84%9C-%EB%B3%B4%EA%B3%A0%EB%90%9C-%ED%95%B5%EC%8B%AC-%EA%B5%AC%EC%84%B1%EC%9A%94%EC%86%8C" class="hash-link" aria-label="요약 — 논문에서 보고된 핵심 구성요소에 대한 직접 링크" title="요약 — 논문에서 보고된 핵심 구성요소에 대한 직접 링크" translate="no">​</a></h2>
<p>AgentsCAD의 파이프라인(초록 기반 요약)은 다음 단계로 구성됩니다.</p>
<ul>
<li class="">입력: STEP 파일 형태의 B-Rep(경계 표현) 모델 파싱.</li>
<li class="">결함 감지: 45° 이상인 과대격차(overhang)를 탐지.</li>
<li class="">토폴로지 구성: 면-인접성(face-adjacency) 토폴로지 그래프 구성.</li>
<li class="">(선택적) 의미 레이블 주입: MFCAD++(약 59,665 파트)로 학습한 GraphSAGE 모델을 통해 의미적 기하학적 특징을 예측하여 그래프에 주석 추가.</li>
<li class="">설계 추론: Claude Sonnet 기반 설계-추론 에이전트가 재배치(reorientation), 필렛(fillet), 챔퍼(chamfer) 등 수정 권고 생성.</li>
<li class="">검증: GPT-4o 비전-언어(verifier)가 렌더링된 뷰를 검사하여 기하학적 무결성 확인.</li>
<li class="">출력: 수정된 STEP 파일과 인간 판독 가능한 리포트.</li>
</ul>
<p>초록에 명시된 바에 따르면, birdhouse 모델 테스트에서 시스템이 과대격차 진단, 결함 완화 전략 선택, 그리고 물리적으로 타당한 수정 제안을 부분적으로 성공적으로 수행했다고 합니다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="기술적-해설">기술적 해설<a href="https://ql.gl/ko/blog/01427437/#%EA%B8%B0%EC%88%A0%EC%A0%81-%ED%95%B4%EC%84%A4" class="hash-link" aria-label="기술적 해설에 대한 직접 링크" title="기술적 해설에 대한 직접 링크" translate="no">​</a></h2>
<ol>
<li class="">입력 데이터와 표현</li>
</ol>
<ul>
<li class="">STEP / B-Rep: 논문은 STEP 파일을 파싱해 B-Rep(경계 표현) 정보를 사용한다고 명시합니다. B-Rep는 면, 경계, 정점 정보를 직접 다루기 때문에 단순 메시(mesh)보다 연속적인 기하학적 연산(예: 필렛 계산, 면 인접성 검사)에 유리합니다.</li>
</ul>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: B-Rep</div><div class="admonitionContent_BuS1"><p>쉬운정의: 객체 표면을 면(face), 모서리(edge), 꼭짓점(vertex) 단위로 기술한 CAD 표현 방식입니다.
일상 예시: 종이 모형을 접어서 한 장의 종이로 집 모양을 만들 때, 각 면과 모서리를 따로 정의해두는 느낌입니다.</p></div></div>
<ol start="2">
<li class="">과대격차(overhang) 감지 및 물리적 제약</li>
</ol>
<ul>
<li class="">AgentsCAD는 45° 임계값을 사용해 과대격차를 진단합니다(초록에 명시). 이는 FDM 출력에서 일반적으로 요구되는 지지 구조 사용과 연관됩니다.</li>
<li class="">논문 초록은 시스템이 적절한 결함 완화 전략(재배치, 필렛, 챔퍼 등)을 <em>제안</em>한다고 보고하지만, 제안된 수정이 실제 프린터별 공정 변수(재료, 온도, 프린터 기하 허용오차)와 전부 검증되었는지에 대한 정량적 결과는 초록에서 확인되지 않습니다. 따라서 현장 적용 전에는 물리적 출력 테스트와 파라미터 튜닝이 필요합니다.</li>
</ul>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 과대격차 (overhang)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 프린트 중에 새로운 레이어가 이전 레이어의 아래 지지 없이 일정 각도 이상으로 노출되는 형상입니다.
일상 예시: 마치 탁자 위에 접시를 반쯤 걸쳐놓았을 때, 접시의 아래가 지지받지 못하는 상황과 비슷합니다.</p></div></div>
<ol start="3">
<li class="">그래프 기반 기하학적 토폴로지와 GraphSAGE</li>
</ol>
<ul>
<li class="">AgentsCAD는 면-인접성 그래프를 구성해 토폴로지 정보를 이용합니다. 이런 그래프 구조는 기하학적 관계(어떤 면이 어떤 면과 붙어 있는지)를 LLM과 결합할 때 유용한 중개 표현이 됩니다.</li>
<li class="">초록에는 GraphSAGE를 MFCAD++(59,665 파트) 데이터셋으로 학습해 의미적 feature label을 주입한다고 명시되어 있습니다. 이는 전통적 기하학 알고리즘으로 포착하기 어려운 '의미' 정보를 보강하기 위한 조치로 보입니다.</li>
</ul>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: GraphSAGE</div><div class="admonitionContent_BuS1"><p>쉬운정의: 그래프의 노드 임베딩을 학습하는 방법 중 하나로, 인접 노드의 특성들을 샘플링해 집계함으로써 각 노드의 표현을 만듭니다.
일상 예시: 친구들 취향을 일부 참고해 어떤 친구의 음식 취향을 예측하는 것과 비슷합니다(이웃 정보를 모아 대표값을 만듦).</p></div></div>
<ol start="4">
<li class="">다중 에이전트 LLM 추론 및 검증 루프</li>
</ol>
<ul>
<li class="">핵심 차별점은 기하학-언어 간 변환을 다중 에이전트 LLM 체계로 처리하는 점입니다. 초록은 Claude Sonnet을 설계-추론 에이전트로, GPT-4o 비전-언어 모델을 검증기(verifier)로 사용했다고 보고합니다.</li>
<li class="">이런 에이전트 조합은 (1) 구조적 결함을 언어로 설명하고, (2) 언어적 지침을 다시 기하학적 수정 제안으로 환원하며, (3) 렌더링 기반 검사로 수정의 무결성을 확인하는 순환을 형성합니다.</li>
</ul>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: LLM (대형 언어 모델)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 대규모 텍스트 데이터를 학습해 언어 생성 및 이해를 수행하는 신경망 모델입니다.
일상 예시: 많은 책과 문서를 읽고 사람처럼 문장을 만들어주는 고도의 자동화된 글쓰기 도우미라고 보면 됩니다.</p></div></div>
<ol start="5">
<li class="">출력물 및 인간 판독 리포트</li>
</ol>
<ul>
<li class="">초록은 수정된 STEP 파일과 인간 판독 가능한 리포트를 출력한다고 명시합니다. 이는 자동화와 함께 설계자가 결과를 검토하고 수동 조정을 가할 수 있도록 돕는 실용적 구성입니다.</li>
</ul>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="적용-사례와-검증-범위--증거-기반-해석">적용 사례와 검증 범위 — 증거 기반 해석<a href="https://ql.gl/ko/blog/01427437/#%EC%A0%81%EC%9A%A9-%EC%82%AC%EB%A1%80%EC%99%80-%EA%B2%80%EC%A6%9D-%EB%B2%94%EC%9C%84--%EC%A6%9D%EA%B1%B0-%EA%B8%B0%EB%B0%98-%ED%95%B4%EC%84%9D" class="hash-link" aria-label="적용 사례와 검증 범위 — 증거 기반 해석에 대한 직접 링크" title="적용 사례와 검증 범위 — 증거 기반 해석에 대한 직접 링크" translate="no">​</a></h2>
<p>논문 초록은 birdhouse 모델에서의 테스트 결과를 간략히 언급합니다. 구체적으로 "시스템이 과대격차를 정확히 진단하고, 적절한 결함 완화 전략을 선택하며, 물리적으로 타당한 수정 제안을 제시"했다고 합니다. 다만 다음과 같은 불확실성이 존재합니다:</p>
<ul>
<li class="">정량적 성능 지표(정확도, 오탐/미탐 비율), 실제 프린트 성공률, 혹은 수정 후 기계적 강도 개선 등의 수치는 초록에 포함되어 있지 않습니다.</li>
<li class="">GraphSAGE 학습 세부(하이퍼파라미터, 정확도, 검증 분할 등)와 LLM 에이전트의 prompting/체인오브스텝 구현 세부는 제공된 메타데이터에서 확인되지 않습니다.</li>
</ul>
<p>따라서 본 게시글은 논문 초록과 페이지 메타데이터에 기반한 요약/분석이며, 구현 재현이나 프로덕션 적용을 위해서는 논문 본문(PDF)과 코드/데이터(저자가 공개한 경우)를 직접 참조해야 합니다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="실무적-함의-및-한계">실무적 함의 및 한계<a href="https://ql.gl/ko/blog/01427437/#%EC%8B%A4%EB%AC%B4%EC%A0%81-%ED%95%A8%EC%9D%98-%EB%B0%8F-%ED%95%9C%EA%B3%84" class="hash-link" aria-label="실무적 함의 및 한계에 대한 직접 링크" title="실무적 함의 및 한계에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class="">의의: AgentsCAD는 CAD의 구조적 표현(B-Rep)과 LLM의 자연어 추론을 결합해 설계-제조 간 갭을 메우려는 의미 있는 시도입니다. 특히 토폴로지 그래프와 기계학습 기반 의미 레이블을 결합함으로써 LLM이 더 정확한 컨텍스트를 바탕으로 제안을 생성할 수 있게 합니다.</li>
<li class="">제한: 초록 수준의 보고만으로는 실험적 재현성(예: 파라미터, 데이터 전처리, 렌더링 파이프라인 설정)을 판단하기 어렵습니다. FDM 출력의 성공은 재료, 프린터 설정, 서포트 전략 등 다수의 공정 매개변수에 의존하므로 현장 실험이 필수입니다.</li>
</ul>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="결론-및-권장-리소스">결론 및 권장 리소스<a href="https://ql.gl/ko/blog/01427437/#%EA%B2%B0%EB%A1%A0-%EB%B0%8F-%EA%B6%8C%EC%9E%A5-%EB%A6%AC%EC%86%8C%EC%8A%A4" class="hash-link" aria-label="결론 및 권장 리소스에 대한 직접 링크" title="결론 및 권장 리소스에 대한 직접 링크" translate="no">​</a></h2>
<p>AgentsCAD는 기하학적 특징 인식과 다중 에이전트 LLM을 연결해 DFAM 작업을 자동화하려는 흥미로운 접근입니다. 보다 깊은 기술적 재현을 원한다면 다음을 권장합니다:</p>
<ul>
<li class="">논문 본문(PDF)을 검토해 실험 절차, 하이퍼파라미터, 데이터셋 세부를 확인하세요(초록만으로는 불충분).</li>
<li class="">저자가 공개한 코드/모델/데이터가 있다면 이를 바탕으로 birdhouse와 유사한 간단한 케이스로 엔드투엔드 파이프라인을 복제·검증하세요.</li>
<li class="">실제 FDM 출력에서 제안된 수정의 효과를 평가하려면 프린팅 후 물리적 검사(치수정밀도, 기계적 강도, 표면품질)를 추가로 수행해야 합니다.</li>
</ul>
<p>참고: 본 글은 arXiv 초록 및 공개 메타데이터를 근거로 작성되었습니다. 본문과 구현 세부는 원문 PDF 및 저자 제공 자료를 직접 확인해 보시기 바랍니다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="sources">Sources<a href="https://ql.gl/ko/blog/01427437/#sources" class="hash-link" aria-label="Sources에 대한 직접 링크" title="Sources에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class=""><a href="https://arxiv.org/abs/2607.02448v1" target="_blank" rel="noopener noreferrer" class="">AgentsCAD: Automated Design for Manufacturing of FDM Parts via Multi-Agent LLM Reasoning and Geometric Feature Recognition</a> — license: <code>CC BY 4.0</code>, retrieved: <code>2026-07-06</code>.</li>
<li class="">Image: <a href="https://ql.gl/ko/assets/files/cover-c66011d47ed25a8a8fa13763654cd328.webp/" target="_blank" class="">AI-generated cover image via OpenRouter</a> — license: <code>ai-generated-original</code>.</li>
</ul>]]></content>
        <author>
            <name>p4r4d0xb0x</name>
            <uri>https://bdev.io</uri>
        </author>
        <category label="AI" term="AI"/>
        <category label="LLM" term="LLM"/>
        <category label="Automation" term="Automation"/>
        <category label="Research" term="Research"/>
        <category label="Explainer" term="Explainer"/>
    </entry>
    <entry>
        <title type="html"><![CDATA[Best AI agent red teaming tools in 2026: 기능, 한계, 그리고 도입 고려사항]]></title>
        <id>https://ql.gl/ko/blog/edbc94f6/</id>
        <link href="https://ql.gl/ko/blog/edbc94f6/"/>
        <updated>2026-07-06T00:00:00.000Z</updated>
        <summary type="html"><![CDATA[2026년 기준 에이전트형 AI(red-teaming) 도구 비교와 평가 프레임워크. 보안·품질 통합, 에이전트 네이티브 테스트, 취약점 대응 파이프라인, 그리고 조직적 프로세스화를 중심으로 요약합니다. 출처 자료의 범위와 한계도 명시합니다.]]></summary>
        <content type="html"><![CDATA[<p>본 글은 제공된 자료(2026-06-04 게시물)를 근거로 9개 주요 AI 에이전트(red-teaming) 도구의 비교와, 실무에서 유의할 핵심 질문들을 요약·분석합니다. 자료는 제품별 강점과 한계, 그리고 에이전트형 AI 테스트에서 중요한 네 가지 평가 축(보안·품질 통합, 에이전트 네이티브 여부, 취약점 대응 흐름, 제품 대 프로세스)을 중심으로 구성되어 있습니다. 제공된 원문은 도구별 설명과 제한점을 담고 있으나, 일부 구현 세부(예: 내부 아키텍처, 정확한 탐지율, 비용 데이터)는 공개 증거에 포함되어 있지 않으므로 그 점은 본문에서 명시합니다.</p>
<!-- -->
<p><img decoding="async" loading="lazy" src="https://ql.gl/ko/assets/images/cover-3d2fc5fa601fe75cb08c75a2a7043190.webp" width="1200" height="675" class="img_ev3q"></p>
<p>요약 요점:</p>
<ul>
<li class="">에이전트형 AI(agentic AI)는 단일 프롬프트-응답 모델 테스트로는 드러나지 않는 취약점을 만든다. 도구 선택 시 "모델용인지(단일턴) 혹은 에이전트용인지(다중턴·도구호출·상태관리)"를 반드시 확인해야 한다.</li>
<li class="">보안과 품질(예: 과열렬 응답, 과도한 거부)은 분리된 문제로 다루면 실제 운영에서 상충하는 결정으로 이어진다. 둘을 함께 평가하는 도구가 더 실무적이다.</li>
<li class="">탐지만 하는 도구와 "탐지→우선순위화→회귀테스트→런타임 가드레일"로 이어지는 플로우를 제공하는 도구는 장기적 가치가 크게 다르다.</li>
<li class="">조직 내에서 단순 제품 설치가 아니라, 도구를 조직 프로세스에 녹여내는 관리·운영 역량(도메인 지식, 과제 할당, CI/CD 연동 등)이 핵심 차별점이다.</li>
</ul>
<p>주요 보존 이미지와 논의 (자료에서 직접 제공된 이미지를 유지합니다):</p>
<p><img decoding="async" loading="lazy" src="https://cdn.prod.website-files.com/601d6f7e527cf16fd11a1aae/6942c6ea461790c2e41ab56a_OWASP%20agentic%202026.png" alt="OWASP top 10 for agentic applications 2026" class="img_ev3q">
이 이미지는 2026년 기준 에이전트형 애플리케이션에 대한 우선순위형 위험 목록(OWASP 에이전트용 Top 10)을 시각화합니다. 이유: 에이전트 특유의 위험(목표 탈취, 도구 오용 등)은 단일턴 모델 취약점과 달라 도구 평가 기준이 바뀝니다.</p>
<p><img decoding="async" loading="lazy" src="https://cdn.prod.website-files.com/601d6f7e527cf16fd11a1aae/698dc291484bd14db95d5944_CoT%20Forgery.png" alt="CoT Forgery: The Chain-of-Thought vulnerability in LLM security" class="img_ev3q">
체인-오브-씽트(CoT) 위조 이미지는 모델의 내부 사고(Chain-of-Thought)를 악용하는 공격 유형을 보여줍니다. 이유: 일부 평가 파이프라인은 LLM 판정자를 사용해 결과를 메타평가하는데, 이때 CoT 취약성은 평가 정확도를 떨어뜨릴 수 있어 메타-검증 과정 설계가 중요합니다.</p>
<p><img decoding="async" loading="lazy" src="https://cdn.prod.website-files.com/601d6f7e527cf16fd11a1aae/6a21cacf68089ad85d560efd_Top%209%20AI%20agents%20red%20teaming.png" alt="Best AI agent red teaming tools in 2026 to detect vulnerabilities" class="img_ev3q">
원문에 수록된 비교 이미지(Top 9 도구)는 각 도구의 포지셔닝을 한눈에 보여줍니다. 이유: 도구 선택 시 어떤 축(에이전트 네이티브, CI/CD 통합, 가드레일, 오픈소스 여부 등)을 중시하는지 판단하는 출발점이 됩니다.</p>
<p>주의: 원문은 도구별 기능·강점·한계를 비교 분석하고 있으나, 독립적인 성능 지표(탐지율, 오탐률)나 고객사별 실제 사례의 상세성을 모두 제공하지는 않습니다. 따라서 본 문서는 원문 근거의 요약·해석이며, 도입 전 자체 PoC와 재현 테스트를 권고합니다.</p>
<p>핵심 평가 프레임워크(원문 기준 요약)</p>
<ol>
<li class="">
<p>보안과 품질을 함께 평가하는가?</p>
<ul>
<li class="">단순한 프롬프트 인젝션·탈취 검사 외에 환각(hallucination), 충성도(sycophancy), 과도한 거부(over-refusal) 등 품질 문제를 함께 탐지해야 실무에서의 트레이드오프를 이해할 수 있습니다.</li>
</ul>
</li>
<li class="">
<p>모델(Level)용 도구인가, 에이전트(Agentic)용 도구인가?</p>
<ul>
<li class="">에이전트 테스트는 "글로벌 평가(global evaluation)"(도구 호출, 호출 인자, 상호작용 이력 평가)와 "글로벌 시뮬레이션(global simulation)"(도구 응답·시스템 상태를 모킹한 다중턴 시나리오)이 필요합니다. 모델 단일턴 스캐너로는 에이전트 리스크의 상당 부분을 놓칩니다.</li>
</ul>
</li>
<li class="">
<p>탐지 이후의 파이프라인을 제공하는가?</p>
<ul>
<li class="">취약점 → 우선순위 태스크 → 회귀 테스트 → 런타임 가드레일(패치)로 이어지는 흐름을 제공하면 실제 개선이 가능합니다. 단순 보고서만 출력하면 지속적 보증이 어렵습니다.</li>
</ul>
</li>
<li class="">
<p>도구를 제품으로 보나, 프로세스로 보나?</p>
<ul>
<li class="">도메인 지식(규제·비즈니스 위험)을 도구 설정에 반영하고, 조직 내 역할에 따라 워크플로우를 제공하는 도구가 더 효과적입니다.</li>
</ul>
</li>
</ol>
<p>원문에서 소개한 도구별 요약 (핵심만 발췌)</p>
<ul>
<li class="">Giskard: 보안·품질 통합, 에이전트 네이티브 평가, 취약점→태스크/회귀/가드레일 파이프라인 제공. EU(프랑스) 기반으로 데이터 주권 관련 어필 포인트가 있습니다. 다만 OSS 버전은 엔터프라이즈 기능 일부를 포함하지 않습니다.</li>
<li class="">Promptfoo: 개발자-친화적 CI/CD 중심 도구. OpenAI 인수(2025)로 중립성 우려가 제기됩니다. CLI/데브옵스 중심 사용 사례에 강점.</li>
<li class="">NVIDIA Garak: 모델 수준에서 폭넓은 정적 프로브 라이브러리(120+ 카테고리). 에이전트·다중턴 모사에는 제한.</li>
<li class="">PyRIT(마이크로소프트): Azure 친화적 프레임워크. 공격 오케스트레이션 설계에 강점, 그러나 에이전트 행동 모킹과 협업 기능은 제한적.</li>
<li class="">DeepTeam(Confident AI): 레드팀·런타임 가드레일 통합. 파이썬 API 기반으로 엔지니어 중심 배포에 적합.</li>
<li class="">Splx AI: 레드팀→자동 완화(프롬프트 하드닝)→런타임 가드레일 통합으로 풀사이클 제공. 인수·통합 이력에 따라 제품 로드맵 불확실성 존재.</li>
<li class="">Mindgard, Lasso, HiddenLayer: 각각 매니지드 서비스, 자산 인벤토리·공격 표면 맵핑, 기존 보안 스택 확장에 강점. 일반적으로 품질 테스트(환각 등)에는 상대적 약점이 보고됩니다.</li>
</ul>
<p>실무 권장 체크리스트</p>
<ul>
<li class="">에이전트인지 모델인지: 당신의 서비스가 도구 호출·상태관리·다중턴 상호작용을 한다면 반드시 에이전트-네이티브 지원 확인</li>
<li class="">보안·품질 통합 여부: 오탐으로 인한 사용자 경험 저하 위험을 최소화하려면 둘을 같은 스캔에서 비교·분석하는 도구 선호</li>
<li class="">취약점 처리 흐름: 보고서만 나오는지, CI/CD 회귀·태스크화·런타임 가드레일로 연결되는지 확인</li>
<li class="">조직 통합성: 도메인 전문가(업무 담당자)가 시나리오를 만들고 우선순위를 정할 수 있는 협업 UI/워크플로우 존재 여부</li>
<li class="">거버넌스·주권: EU 데이터 레지던시·공급망 위험 등 규제 요구가 있다면 제공업체의 법적/지리적 위치 검토</li>
</ul>
<p>용어 해설</p>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: 에이전트형 AI (Agentic AI)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 에이전트형 AI는 단순히 프롬프트에 답하는 모델이 아니라, 외부 도구를 호출하거나 상태를 유지·갱신하면서 자동으로 작업을 수행하는 시스템입니다.
일상 예: 이메일을 자동으로 읽고, 첨부파일을 분석한 뒤 일정에 초안을 자동 추가하는 챗봇.</p></div></div>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: OWASP LLM Top 10 (Agentic 변형)</div><div class="admonitionContent_BuS1"><p>쉬운정의: OWASP LLM Top 10은 LLM/에이전트 애플리케이션에서 우선순위로 다뤄야 할 위험 목록을 정리한 프레임워크입니다(2026년판에는 에이전트 특유의 위험 항목이 추가됨).
일상 예: 웹 개발에서 SQL 인젝션 같은 흔한 위협 목록이 있어 테스트 우선순위를 정하듯, 에이전트용 OWASP는 어떤 공격을 먼저 검사해야 하는지 알려줍니다.</p></div></div>
<div class="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><div class="admonitionHeading_Gvgb"><span class="admonitionIcon_Rf37"><svg viewBox="0 0 12 16"><path fill-rule="evenodd" d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>용어 해설: MCP (Model Control Plane / 도구·MCP 서버 관련)</div><div class="admonitionContent_BuS1"><p>쉬운정의: 본문에서 MCP는 에이전트가 도구 호출이나 외부 서비스와 통신할 때 사용하는 제어면(서버) 또는 인터페이스를 뜻합니다. MCP의 잘못된 설정은 권한 과다 요청·민감 데이터 노출 등을 초래합니다.
일상 예: 스마트홈 중앙 허브(예: 조명·난방을 통합 제어하는 서버)가 잘못 설정되면 모든 기기가 위험해지는 것과 유사합니다.</p></div></div>
<p>마무리 및 한계</p>
<p>원문은 각 도구의 장단점과 2026년 시장 지형을 정리하고 있으며, 특히 "에이전트 네이티브 테스트"와 "탐지→수정→회귀→런타임 가드"의 중요성을 반복합니다. 다만, 게시물은 제품별 정량적 성능 메트릭(예: 탐지율, 오탐률), 실제 고객 사례의 심층적 재현, 세부 비용 구조 등은 공개하지 않았습니다. 따라서 도입 전에는 자체 PoC를 통해 해당 도구가 귀사 환경에서 유효하게 작동하는지를 검증하시기 바랍니다.</p>
<p>참고: 본 문서는 제공된 HTML 근거 문서를 요약·해석한 것이며, 원문이 다루지 않은 기술적 세부나 최신 업데이트는 별도 확인이 필요합니다.</p>
<h2 class="anchor anchorTargetHideOnScrollNavbar_vjPI" id="sources">Sources<a href="https://ql.gl/ko/blog/edbc94f6/#sources" class="hash-link" aria-label="Sources에 대한 직접 링크" title="Sources에 대한 직접 링크" translate="no">​</a></h2>
<ul>
<li class=""><a href="https://www.giskard.ai/knowledge/best-ai-agent-red-teaming-tools-in-2026-understanding-features-functions-and-solutions" target="_blank" rel="noopener noreferrer" class="">Best AI agent red teaming tools in 2026: understanding features, functions and solutions</a> — license: <code>unknown</code>, retrieved: <code>2026-07-06</code>.</li>
<li class="">Image: <a href="https://ql.gl/ko/assets/files/cover-3d2fc5fa601fe75cb08c75a2a7043190.webp/" target="_blank" class="">AI-generated cover image via OpenRouter</a> — license: <code>ai-generated-original</code>.</li>
</ul>]]></content>
        <author>
            <name>p4r4d0xb0x</name>
            <uri>https://bdev.io</uri>
        </author>
        <category label="Security" term="Security"/>
        <category label="AI" term="AI"/>
        <category label="LLM" term="LLM"/>
        <category label="Research" term="Research"/>
        <category label="Explainer" term="Explainer"/>
    </entry>
</feed>