📃Weight Sparse Transformers 리뷰

Weight-sparse transformers have interpretable circuits

🔍 Ping. 🔔 Ring. ⛏️ Dig. A tiered review series: quick look, key ideas, deep dive.

• Paper Link
• Code
• Posting

1. 🤖 이 연구는 언어 모델의 작동 원리를 이해하기 위해 대부분의 가중치를 0으로 제한한 weight-sparse Transformer를 훈련하고, 각 task에 대한 핵심 circuit을 pruning함으로써 인간이 이해할 수 있는 circuit을 추출합니다.
2. 🔍 Weight-sparse 모델은 dense 모델보다 훨씬 작고(약 16배) 명확하게 해석 가능한 task-specific circuit을 생성하며, 이 circuit들은 자연스러운 개념과 직관적인 연결을 통해 높은 수준의 이해도를 제공합니다.
3. 📈 모델 크기를 확장하면 해석 가능성과 성능 간의 Pareto frontier가 개선되지만, 수천만 개의 비-제로 파라미터 이상으로 확장하면서 해석 가능성을 유지하는 것은 여전히 도전 과제이며, 제안된 방법은 bridge를 통해 기존 dense 모델의 동작을 설명하는 데에도 적용될 수 있음을 보여줍니다.

---

🔍 Ping Review

🔍 Ping — A light tap on the surface. Get the gist in seconds.

이 논문은 mechanistic interpretability 분야의 핵심 목표인 language model 내에서 사람의 이해가 가능한 circuit을 찾는 방법을 제시합니다. 기존 dense 모델의 superposition 문제로 인해 circuit을 이해하기 어려운 문제를 해결하기 위해, 대부분의 가중치가 0인 weight-sparse transformer를 훈련합니다. 이 모델들은 각 뉴런이 소수의 연결만을 가지도록 하여 모델의 연산을 극적으로 단순화합니다.

핵심 방법론 (Core Methodology)

1. Weight-Sparse Model 훈련 (Sparse Training):
   • 아키텍처 (Architecture): GPT-2 스타일의 decoder-only transformer를 사용하며, 모든 가중치와 bias에 sparsity를 적용합니다. 이로 인해 모델의 width를 늘리면서도 0이 아닌 파라미터(L0 norm)의 수를 일정하게 유지할 수 있습니다. 가장 희소한 모델은 약 1/1000의 가중치만 0이 아닙니다. 또한, 모든 node 위치에서 약 1/4의 activation이 0이 아닌 “mild activation sparsity”를 AbsTopK 활성화 함수를 통해 강제합니다. RMSNorm을 사용하여 residual stream에서 0 값이 특별한 의미를 가지도록 하고, normalization 가중치를 MLP/attention 가중치에 통합하여 L0를 변경하지 않습니다.
   • 최적화 (Optimization): AdamW optimizer를 사용하여 cross-entropy loss를 최소화합니다. L0 가중치 희소성 제약 조건을 유지하기 위해 각 훈련 단계에서 AdamW를 적용한 후 각 가중치 행렬에서 가장 큰 magnitude를 가진 entry를 제외한 나머지를 0으로 설정합니다. 훈련 과정 동안 L0 norm을 fully dense 상태에서 목표 L0까지 선형적으로 annealing합니다. Gradient clipping, learning rate warmup 및 L0에 비례하는 learning rate 스케줄을 사용합니다. 특정 뉴런이나 attention channel이 최소 j=4개의 0이 아닌 값을 가지도록 강제하여 dead neuron을 줄입니다.
2. 해석 가능성 측정 (Measuring Interpretability):
   • 태스크 분포 (Task Distribution): 20가지의 간단하고 명확한 Python next-token 이진 예측 태스크를 수동으로 구성합니다. 예시로는 single double quote (문자열 닫는 따옴표 예측) 및 bracket counting (괄호 중첩 깊이 세기) 등이 있습니다.
   • 가지치기 (Pruning): 각 태스크에 대해 모델을 가지치기하여 태스크 분포에서 목표 loss(기본값 0.15)를 달성하는 가장 작은 circuit을 얻습니다. 가지치기는 모든 토큰 위치에서 node의 부분 집합을 삭제하는 방식으로 이루어집니다. 삭제된 node들은 mean-ablated되는데, 이는 해당 node의 activation이 pretraining 분포에서 평균 activation 값으로 고정됨을 의미합니다.
     • Structured Pruning Algorithm: 각 node(i)에 대해 mask parameter \tau_i를 학습합니다. 이 mask는 node 위치 x_i를 x_i \odot \sigma(\tau_i)로 게이팅하는 데 사용되며, 여기서 \sigma는 Heaviside step function입니다. sigmoid-derivative surrogate gradient를 사용하여 Heaviside step function을 통해 역전파하여 \tau_i를 훈련합니다. 태스크 loss와 circuit 크기(mask의 0이 아닌 요소 수)의 joint objective를 최소화합니다.
     • Node 및 Edge 정의: “node”는 개별 뉴런, attention channel, residual channel read, residual channel write를 의미하는 가장 세분화된 단위입니다. “edge”는 가중치 행렬의 0이 아닌 entry로, 두 node를 연결합니다.
   • 해석 가능성 지표: 구성된 태스크 전반에 걸쳐 circuit의 edge 수의 기하 평균을 주요 정량적 해석 가능성 지표로 사용합니다.
3. Dense 모델을 위한 브릿지 (Bridges):
   • 기존 dense 모델을 이해하기 위해, dense 모델과 weight-sparse 모델의 activation 사이에 매핑되는 일련의 bridges를 학습합니다. 각 bridge는 dense에서 sparse로 매핑하는 encoder와 sparse에서 dense로 매핑하는 decoder로 구성됩니다.
   • 손실 항 (Loss Terms):
     • Normalized MSE: 브릿지 인코더가 dense activation으로부터 sparse activation을 정확하게 예측하고, 그 반대도 마찬가지인지 훈련합니다: L_{NMSE} = \sum_i (NMSE(f_i(h^d_i), h^s_i) + NMSE(g_i(h^s_i), h^d_i)).
     • KL Divergence: sparse 모델이 dense 모델의 activation을 수용하고 dense 모델이 sparse 모델의 activation을 수용하도록 훈련합니다. 이는 dense 및 sparse 레이어의 혼합을 통한 hybrid forward pass의 출력 logit과 원래 dense 모델의 logit 간의 KL divergence를 최소화합니다: L_{KL,d \to s} = \sum_i KL(y^d, (M^s_{unemb} \circ M^s_L \circ \cdots \circ M^s_i \circ f_i)(h^d_i)) L_{KL,s \to d} = \sum_i KL(y^d, (M^d_{unemb} \circ M^d_L \circ \cdots \circ M^d_i \circ g_i)(h^s_i))

주요 결과 (Results)

• 해석 가능성 향상: Weight-sparse 모델은 dense 모델과 유사한 pretraining loss를 가질 때, 태스크별 circuit이 16배 더 작습니다. 이 circuit들은 모델 행동에 대해 충분하고 필수적임이 검증되었습니다.
• 스케일링 특성: 모델 크기를 확장하면(total parameter count 증가) capability-interpretability Pareto frontier가 개선됩니다. L0 norm을 줄이면 capability와 interpretability 사이의 trade-off가 발생합니다.
• 정성적 circuit 분석:
  • Closing Strings: 0.mlp 레이어의 두 뉴런이 “quote detector”와 “quote type classifier” residual channel을 생성하고, 10.attn.head82가 이를 key와 value로 사용하여 문자열을 닫는 두 단계 메커니즘을 밝혀냈습니다.
  • Counting Nesting Depth: [ 토큰 임베딩이 “bracket detector”가 되고, 2.attn 헤드가 열린 괄호 수를 평균하여 “list depth”를 residual channel 1249에 인코딩합니다. 이후 4.attn 헤드가 attention sink를 사용하여 list depth를 이진 출력으로 thresholding합니다. 이 이해를 통해 모델을 속이는 adversarial example을 성공적으로 구성했습니다.
  • Tracking Variable Type: set or string 태스크에서 layer 4 attention head가 변수 이름(current)을 set() 또는 "" 토큰으로 복사하고, layer 6 attention head가 이 정보를 최종 토큰 위치로 복사하는 두 단계 알고리즘을 발견했습니다.
• 기존 모델 설명 (Bridges): Weight-sparse 모델과 dense 모델 사이에 bridge를 훈련하여 dense 모델의 표현을 조작할 수 있음을 보여주었습니다. sparse 모델에서 “quote type classifier” 또는 “current line begins with”와 같은 node를 조작하고 이를 bridge를 통해 dense 모델로 매핑하여 dense 모델의 행동(예: 따옴표 유형 예측, 콜론 출력)을 원하는 방식으로 변경할 수 있었습니다.

논의 및 한계 (Discussion & Limitations)

• Weight-sparse 모델은 dense 모델보다 훈련 및 추론 컴퓨팅 비용이 매우 비효율적입니다 (100-1000배). 이로 인해 최전선(frontier) 모델을 완전히 해석하거나 de novo로 훈련하기는 어렵습니다.
• 미래 방향으로는 interpretable model organism을 GPT-3 수준까지 확장하여 보편적인 circuit motif를 연구하거나, 특정 중요한 태스크(예: deception)에 대해 sparse bridged model을 훈련하는 것을 제안합니다. 또한, sparse circuit이 자동화된 해석 가능성(automated interpretability)의 새로운 기본 요소를 제공할 수 있다고 봅니다.
• 한계점으로는 컴퓨팅 비효율성, 여전히 나타나는 polysemantic features, 이진화되지 않는 feature의 존재, mean ablation의 faithfulness 한계, 해석 가능성 정의의 확장 필요성, 가지치기 방법 개선, 그리고 복잡한 태스크와 대규모 모델에 대한 스케일링 불확실성 등이 있습니다.

🔔 Ring Review

🔔 Ring — An idea that echoes. Grasp the core and its value.

🧠 AI의 블랙박스를 열다

🎯 들어가며: 왜 이 논문이 중요한가?

여러분, 혹시 자동차 엔진 후드를 열어본 적 있으신가요? 대부분의 사람들은 자동차가 “어떻게” 움직이는지 정확히 모르면서도 매일 운전을 합니다. 핸들을 돌리면 차가 돌아가고, 악셀을 밟으면 앞으로 가죠. 그런데 만약 자동차가 갑자기 이상한 행동을 한다면? 아무도 왜 그런지 모른다면 어떨까요?

바로 이것이 지금 AI 분야에서 일어나고 있는 일입니다. ChatGPT, Claude, Gemini 같은 대규모 언어 모델(LLM)은 놀라운 능력을 보여주지만, 정작 “왜” 그런 답변을 하는지는 개발자들조차 정확히 모릅니다. 이 논문은 바로 그 “왜”를 이해하기 위한 중요한 한 걸음입니다.

“우리는 신경망의 능력은 빠르게 향상시켰지만, 정작 그것들이 어떻게 작동하는지에 대해서는 거의 이해하지 못하고 있다.”

— 논문 서론에서

---

💡 핵심 아이디어: 레고 블록처럼 단순하게 만들자

복잡한 뇌 vs 단순한 뇌

자, 여기서 파인만 선생님처럼 아주 간단한 비유로 시작해볼게요.

일반적인 신경망은 마치 모든 사람이 모든 사람과 연결된 소셜 네트워크와 같습니다. 100명이 있다면, 한 사람이 99명 모두와 친구인 셈이죠. 누가 누구에게 어떤 정보를 전달했는지 추적하기가 거의 불가능합니다.

반면 이 논문에서 제안하는 Weight-Sparse(가중치-희소) 모델은 마치 각 사람이 딱 3~4명의 친구만 있는 네트워크입니다. 훨씬 추적하기 쉽겠죠?

+---------------------------+---------------------------+
|       Dense Model         |      Sparse Model         |
|     (All connected)       |    (Few connections)      |
|                           |                           |
|       *----*----*         |         *----*            |
|       |\  /|\  /|         |         |    |            |
|       | \/ | \/ |         |         *    *----*       |
|       | /\ | /\ |         |              |            |
|       *----*----*         |         *----*            |
|                           |                           |
|   All neurons connected   |   Only few connections    |
|   -> Hard to trace        |   -> Easy to trace!       |
+---------------------------+---------------------------+

“Superposition” 문제란?

기존 신경망에서 왜 해석이 어려운지 조금 더 깊이 들어가볼까요? 핵심 문제는 바로 “Superposition(중첩)”이라는 현상입니다.

초등학생도 이해할 수 있게 설명해드릴게요. 여러분의 방에 책상이 하나 있다고 상상해보세요. 이 책상 위에 연필, 공책, 스마트폰, 간식을 모두 올려놓아야 합니다. 공간이 넉넉하면 각각 제자리에 놓겠죠. 하지만 책상이 아주 작다면? 연필 위에 공책을 겹쳐 놓고, 스마트폰은 간식 봉지 안에 넣어두는 식으로 “압축”을 해야 합니다.

신경망에서도 비슷한 일이 일어납니다. 뉴런(뉴런 = 신경세포, 즉 계산을 담당하는 작은 단위)의 개수가 표현해야 할 개념의 수보다 적으면, 하나의 뉴런이 여러 개념을 “겹쳐서” 표현합니다. 이것이 바로 Superposition입니다.

🔑 핵심 통찰: 가중치의 대부분을 0으로 만들면, 각 뉴런이 소수의 다른 뉴런들과만 연결되어 “얽힘”이 풀린다!

---

🔬 방법론: 어떻게 희소 모델을 만들었나?

Step 1: Weight-Sparse Training (가중치 희소 학습)

연구진은 GPT-2 스타일의 Transformer 모델을 학습시키되, 한 가지 특별한 제약을 걸었습니다: 가중치(weight)의 대부분을 0으로 유지하는 것입니다.

구체적으로 어떻게 했을까요?

1. AdamW 옵티마이저로 학습 스텝 진행
2. 각 가중치 행렬에서 절대값이 가장 큰 상위 k개만 유지 (나머지는 0으로)
3. 학습 초기에는 Dense(밀집)로 시작해서 점진적으로 Sparse(희소)하게 전환
4. 가장 희소한 모델은 약 1000개 중 1개의 가중치만 0이 아님!

자, 이게 무슨 의미일까요? 일반 모델에서는 하나의 뉴런이 2048개의 다른 뉴런과 연결될 수 있다면, 이 희소 모델에서는 단 2~3개의 뉴런과만 연결됩니다. 마치 복잡하게 얽힌 실타래를 풀어서 깔끔하게 정리한 것과 같죠.

+-----------------------------------------------------------+
|                Training Process Visualization             |
|                                                           |
|  Start (Dense)            -->           End (Sparse)      |
|                                                           |
|  ################                    #.................#  |
|  ################                    .....#............   |
|  ################       Gradual      ..........#......    |
|  ################       Annealing    #.................   |
|  ################          -->       .........#.......    |
|                                                           |
|  (All weights active)              (Only 0.1% active!)    |
+-----------------------------------------------------------+

Step 2: Circuit Pruning (회로 가지치기)

자, 이제 희소 모델을 학습시켰습니다. 그런데 여전히 모델 전체를 이해하기는 어렵죠. 여기서 연구진은 기발한 아이디어를 냅니다: “특정 작업을 수행하는 데 필요한 최소한의 부품만 찾아내자!”

이것을 “Pruning(가지치기)”이라고 합니다. 나무의 불필요한 가지를 쳐내듯이, 특정 작업에 필요 없는 뉴런들을 잘라내는 거죠.

구체적인 방법:

1. 각 노드(뉴런, 어텐션 채널 등)에 마스크(mask) 파라미터를 붙임
2. 마스크가 0이면 해당 노드는 “평균값”으로 대체 (Mean Ablation)
3. “특정 작업의 손실(loss)”과 “회로 크기”를 동시에 최소화하도록 마스크 학습
4. 결과적으로 해당 작업에 꼭 필요한 노드들만 남김

“노드”와 “엣지”란?

이 논문에서 사용하는 중요한 용어들을 정리해볼게요.

노드(Node): 계산을 수행하는 가장 작은 단위입니다. 구체적으로는: - 개별 뉴런 (MLP의 활성화 값) - 어텐션 채널 (Query, Key, Value의 각 차원) - 잔차 스트림(Residual Stream) 채널의 읽기/쓰기

엣지(Edge): 가중치 행렬에서 0이 아닌 값 하나를 의미합니다. 즉, 두 노드 사이의 “연결”이죠.

가장 단순한 MLP 회로를 예로 들면: 하나의 뉴런이 하나의 잔차 채널에서 읽고, 하나의 잔차 채널에 쓰는 경우 → 3개의 노드와 2개의 엣지로 구성됩니다.

---

📊 핵심 결과: 정말 해석 가능해졌나?

결과 1: 16배 더 작은 회로!

연구진은 동일한 성능(pretraining loss)을 가진 Dense 모델과 Sparse 모델을 비교했습니다. 결과는 놀라웠습니다:

✨ 동일한 작업 성능에서, Sparse 모델의 회로는 Dense 모델보다 약 16배 작았습니다!

이게 왜 중요할까요? 회로가 작다는 것은 곧 “이해하기 쉽다”는 것입니다. 1000개의 부품으로 이루어진 기계보다 60개의 부품으로 이루어진 기계가 분석하기 훨씬 쉽겠죠?

+-------------------------------------------------------------+
|                   Circuit Size Comparison                   |
|                                                             |
|  Dense Model   ################################  (~16,000)  |
|                                                             |
|  Sparse Model  ##  (~1,000)                                 |
|                                                             |
|                        ^                                    |
|                   16x smaller!                              |
+-------------------------------------------------------------+

결과 2: 능력 vs 해석가능성 트레이드오프

세상에 공짜 점심은 없습니다. 가중치를 희소하게 만들면 해석가능성은 좋아지지만, 모델의 능력은 어떻게 될까요?

연구진은 이것을 “Pareto Frontier(파레토 경계)”로 분석했습니다. 파레토 경계란 무엇일까요?

자동차를 살 때를 생각해보세요. 연비가 좋으면서 동시에 엄청 빠른 차를 원하지만, 보통은 둘 중 하나를 양보해야 합니다. 이처럼 두 가지 목표(능력 vs 해석가능성) 사이에서 “최선의 선택들”을 연결한 선이 파레토 경계입니다.

연구진이 발견한 것:

1. L₀(0이 아닌 가중치 수)를 줄이면 → 해석가능성 ↑, 능력 ↓
2. 모델 크기(총 파라미터 수)를 늘리면 → 두 가지 모두 개선!

즉, 더 큰 모델을 만들되 희소하게 유지하면, 능력도 좋고 해석도 잘 되는 모델을 만들 수 있습니다. 하지만 현재 기술로는 수천만 개의 비영(非零) 파라미터를 넘어서면 이점이 줄어든다고 합니다.

결과 3: 가중치 희소성이 활성화 희소성을 유도한다

재미있는 부가 발견이 있었습니다. 가중치를 희소하게 만들면, 활성화(activation) 값도 자연스럽게 희소해진다는 것입니다.

이것을 kurtosis(첨도)라는 통계량으로 측정했는데, 가중치가 희소할수록 활성화의 kurtosis가 높아졌습니다. Kurtosis가 높다는 것은 대부분의 값이 0 근처에 모여있고, 가끔 큰 값이 나타난다는 뜻이에요. 이는 각 뉴런이 특정 상황에서만 “불이 켜진다”는 것을 의미하며, 해석하기 더 쉬워집니다.

---

🔍 실제 회로 분석: AI 내부를 들여다보다

이론은 여기까지. 이제 진짜 흥미로운 부분입니다. 연구진은 실제로 모델 내부의 회로를 분석해서, 인간이 이해할 수 있는 알고리즘을 발견했습니다!

사례 1: 문자열 닫기 회로 (String Closing Circuit)

첫 번째 사례는 아주 간단한 작업입니다: Python 코드에서 문자열이 작은따옴표(')로 시작했으면 작은따옴표로 닫고, 큰따옴표(")로 시작했으면 큰따옴표로 닫아야 합니다.

예를 들어: - print("Hello World → 여기서 다음에 올 토큰은? ") - print('Hello World → 여기서 다음에 올 토큰은? ')

발견된 회로 (단 12개의 노드와 9개의 엣지!)

Step 1 - 첫 번째 MLP 레이어(0.mlp): - (" 와 ('의 임베딩을 두 종류의 뉴런으로 변환 - “따옴표 감지기” 뉴런 (채널 985): (", (' 모두에서 양수 - “따옴표 유형 분류기” 뉴런 (채널 460): ("에서 양수, ('에서 음수

Step 2 - 10번째 어텐션 헤드(10.attn.head82): - “따옴표 감지기”를 Key로 사용 → 문자열 시작 위치에 주목 - “따옴표 유형 분류기”를 Value로 사용 → 어떤 따옴표인지 정보 복사 - 마지막 토큰에 올바른 닫는 따옴표 예측!

+----------------------------------------------------------------+
|              String Closing Circuit Diagram                    |
|                                                                |
|   Input: print("Hello                                          |
|                                                                |
|   +----------------------------------------------------------+ |
|   |  Layer 0 (MLP)                                           | |
|   |                                                          | |
|   |  (" token --> [Quote Detector: +] [Quote Type: +]        | |
|   |  (' token --> [Quote Detector: +] [Quote Type: -]        | |
|   +----------------------------------------------------------+ |
|                           |                                    |
|                           v                                    |
|   +----------------------------------------------------------+ |
|   |  Layer 10 (Attention Head 82)                            | |
|   |                                                          | |
|   |  Key: Quote Detector (Where did string start?)           | |
|   |  Value: Quote Type (Which kind of quote?)                | |
|   |                                                          | |
|   |  --> Copy info to last token!                            | |
|   +----------------------------------------------------------+ |
|                           |                                    |
|                           v                                    |
|   Output: ") <-- Correct closing quote!                        |
|                                                                |
+----------------------------------------------------------------+

💡 놀라운 점: 이 4개의 핵심 구성요소는 총 41개의 엣지만 가지고 있고, 그 중 9개만 이 회로에 사용됩니다. 매우 깔끔하게 분리되어 있죠!

---

사례 2: 괄호 중첩 깊이 세기 (Bracket Counting)

두 번째 사례는 조금 더 복잡합니다: Python에서 리스트가 중첩되어 있을 때, 올바르게 괄호를 닫는 것입니다.

• values = [5, 3 → 다음은? ] (단일 리스트)
• values = [[5, 3 → 다음은? ]] (중첩 리스트)

발견된 알고리즘 (3단계)

1️⃣ 임베딩 단계:

[ 토큰의 임베딩이 특정 잔차 채널(759, 826, 1711)에 “열린 괄호 감지기” 역할을 기록합니다.

2️⃣ 카운팅 단계:

2번째 레이어의 어텐션 헤드가 놀라운 일을 합니다. Query와 Key가 거의 0이라서 softmax 후 모든 위치에 동일한 가중치를 부여합니다. 즉, “열린 괄호 감지기”의 컨텍스트 평균을 계산하는 것이죠! 이 평균값이 바로 “중첩 깊이”를 나타내는 신호가 됩니다.

3️⃣ 임계값(Thresholding) 단계:

4번째 레이어의 어텐션 헤드가 “Attention Sink”를 활용합니다. 중첩 깊이가 특정 값을 넘으면 ]]를, 아니면 ]를 출력합니다. Softmax가 자연스럽게 임계값 함수처럼 작동하는 거죠!

+------------------------------------------------------------------+
|                  Bracket Counting Algorithm                      |
|                                                                  |
|  Input: values = [[5, 3                                          |
|                                                                  |
|  Step 1: Embedding                                               |
|  +--------------------------------------------------------------+|
|  |  [ token -> "Open Bracket Detector" activated (+1)           ||
|  |  [ token -> "Open Bracket Detector" activated (+1)           ||
|  |  5, 3 tokens -> Detector inactive (0)                        ||
|  +--------------------------------------------------------------+|
|                              |                                   |
|                              v                                   |
|  Step 2: Counting (Layer 2 Attention)                            |
|  +--------------------------------------------------------------+|
|  |  Q ~ 0, K ~ 0 -> Equal weight to all positions               ||
|  |  = Compute "average" across context                          ||
|  |                                                              ||
|  |  Average = (1 + 1 + 0 + 0) / 4 = 0.5                         ||
|  |  -> This value is the "nesting depth" signal!                ||
|  +--------------------------------------------------------------+|
|                              |                                   |
|                              v                                   |
|  Step 3: Thresholding (Layer 4 Attention + Sink)                 |
|  +--------------------------------------------------------------+|
|  |  Nesting depth > Threshold?                                  ||
|  |                                                              ||
|  |  YES -> Output ]]                                            ||
|  |  NO  -> Output ]                                             ||
|  +--------------------------------------------------------------+|
|                                                                  |
|  Output: ]] <-- Correct closing!                                 |
|                                                                  |
+------------------------------------------------------------------+

🎯 이 이해를 바탕으로 적대적 공격 성공!

연구진은 이 회로의 약점을 정확히 파악했습니다. “평균”을 사용하기 때문에:

• 리스트 앞에 주석으로 [ 문자를 많이 넣으면 → 평균이 높아져서 실수 유발
• 리스트 요소 개수가 매우 많으면 → 평균이 “희석”되어 실수 유발

## 적대적 공격 예시
## Don't get distracted: [ [ [ [ [ [    ← 이 주석이 모델을 혼란시킴!
values = [5, 3]  ## 모델이 ]] 로 잘못 예측!

놀랍게도, 이 적대적 공격은 동일한 능력의 Dense 모델에도 통합니다! 이는 Dense 모델도 비슷한 알고리즘을 사용한다는 간접적 증거입니다.

---

사례 3: 변수 타입 추적 (Variable Type Tracking)

세 번째 사례는 더 고수준의 인지 능력입니다:

• current = set() 이후 → current.add가 적절
• current = "" 이후 → current +=가 적절

발견된 2-hop 알고리즘

Hop 1 (4번째 레이어, Head 73):

최근 토큰에 주목하는 어텐션 헤드가 변수 이름 “current”의 임베딩을 set() 또는 "" 토큰 위치로 복사합니다. 마치 “이 위치에 current라는 변수가 정의되어 있다”고 메모를 남기는 것과 같습니다.

Hop 2 (6번째 레이어, Head 26):

나중에 “current”가 다시 나타나면, 이 헤드는 “current” 임베딩을 Query/Key로 사용해서 앞서 메모해둔 위치(set() 또는 "")를 찾습니다. 그리고 해당 위치의 타입 정보를 마지막 토큰으로 복사해서 올바른 완성을 예측합니다.

+------------------------------------------------------------------+
|              Variable Type Tracking: 2-Hop Algorithm             |
|                                                                  |
|  Code: current = set()                                           |
|        ...                                                       |
|        current.                                                  |
|                                                                  |
|  +--------------------------------------------------------------+|
|  |  Hop 1 (Layer 4, Head 73)                                    ||
|  |                                                              ||
|  |  "current" -----copy----> "set()" position                   ||
|  |                                                              ||
|  |  [Memo: current is defined here!]                            ||
|  +--------------------------------------------------------------+|
|                              |                                   |
|                              v                                   |
|  +--------------------------------------------------------------+|
|  |  Hop 2 (Layer 6, Head 26)                                    ||
|  |                                                              ||
|  |  At "current.":                                              ||
|  |  Q/K = "current" embedding                                   ||
|  |       |                                                      ||
|  |  Find "set()" position -> Copy type info                     ||
|  +--------------------------------------------------------------+|
|                              |                                   |
|                              v                                   |
|  Output: .add <-- Method matching set type!                      |
|                                                                  |
+------------------------------------------------------------------+

---

🌉 Bridge: 기존 모델도 이해할 수 있을까?

Weight-sparse 모델의 큰 단점이 있습니다: 처음부터 새로 학습해야 한다는 것이죠. 이미 배포된 ChatGPT나 Claude 같은 모델을 이해하려면 어떻게 해야 할까요?

연구진은 “Bridge(다리)”라는 영리한 아이디어를 제안합니다.

기본 개념

1. 기존 Dense 모델과 새로운 Sparse 모델을 나란히 놓습니다
2. 각 레이어마다 “Bridge”를 설치합니다 (Linear + Activation)
3. Bridge는 Dense 표현 ↔︎ Sparse 표현 변환을 학습합니다
4. Sparse 모델에서 발견한 “해석 가능한 개입”을 Bridge를 통해 Dense 모델에 적용!

+------------------------------------------------------------------+
|                      Bridge Architecture                         |
|                                                                  |
|  +-------------+                      +-------------+            |
|  | Dense Model |                      |Sparse Model |            |
|  | (Existing)  |                      | (Interpret) |            |
|  +-------------+                      +-------------+            |
|         |                                    |                   |
|         |         +--------------+           |                   |
|  Layer 1+-------->|   Bridge 1   |<----------+Layer 1            |
|         |         | (Encoder/    |           |                   |
|         |         |  Decoder)    |           |                   |
|         |         +--------------+           |                   |
|         |                                    |                   |
|  Layer 2+---------+--------------+-----------+Layer 2            |
|         |         |   Bridge 2   |           |                   |
|         v         +--------------+           v                   |
|        ...                                  ...                  |
|                                                                  |
|  -> Transfer Sparse model's interpretation to Dense model!       |
|                                                                  |
+------------------------------------------------------------------+

실험 결과

연구진은 “따옴표 유형 분류기” 채널을 조작해서, 큰따옴표 문자열에 작은따옴표를 출력하도록 Dense 모델의 행동을 성공적으로 변경했습니다. 이는 Sparse 모델의 해석이 Dense 모델에도 어느 정도 적용된다는 증거입니다.

⚠️ 주의: 이것은 아직 예비적인 결과이며, 모든 회로가 잘 전이되는지는 더 연구가 필요합니다.

---

⚠️ 한계점과 미래 연구 방향

1. 계산 효율성 문제

가장 큰 문제입니다. Sparse 모델은 Dense 모델보다 100~1000배 더 많은 학습/추론 비용이 듭니다.

왜 그럴까요? GPU의 Tensor Core는 밀집(dense) 행렬 연산에 최적화되어 있습니다. 불규칙하게 0이 섞인 희소(sparse) 행렬은 이런 최적화를 활용할 수 없어요. 마치 도로 대신 울퉁불퉁한 오프로드를 달리는 스포츠카와 같습니다.

2. 다의성(Polysemantic) 뉴런

완벽하게 “하나의 뉴런 = 하나의 개념”이 아닙니다. 특히 복잡한 작업에서는 여전히 여러 개념이 소수의 뉴런에 걸쳐 분산되어 있습니다. 다만 Dense 모델보다는 훨씬 나아졌죠.

3. 크기 값(Magnitude)의 의미

뉴런이 “켜졌다/꺼졌다”만 중요한 게 아니라, “얼마나 강하게 켜졌는지”도 의미가 있습니다. 예를 들어 괄호 카운팅에서 중첩 깊이는 활성화의 크기로 인코딩됩니다. 이것을 완전히 이진화(binarize)하기는 아직 어렵습니다.

4. 더 큰 모델로의 확장

현재 실험은 수천만 파라미터 규모에서 진행되었습니다. GPT-3 (1750억 파라미터)이나 GPT-4급 모델에 적용하려면 엄청난 도전이 필요합니다. 연구진은 이것을 “모델 생물(Model Organism)” 연구로 발전시키고자 합니다.

미래 연구 방향

• 더 효율적인 희소 학습 알고리즘 개발
• Mixture-of-Experts와의 결합 (Expert 희소성 + Weight 희소성)
• 자동화된 해석가능성 도구 개발
• 안전성 관련 행동(거부, 속임수 등)에 대한 좁은 범위 Bridge 적용
• 노드 대신 엣지 직접 프루닝

---

📚 관련 연구와 맥락

Sparse Autoencoders (SAE)와의 비교

최근 Anthropic, OpenAI 등에서 Sparse Autoencoders를 사용한 해석가능성 연구가 활발합니다. SAE는 이미 학습된 Dense 모델의 활성화를 희소한 표현으로 재구성합니다.

이 논문의 접근법(Weight Sparsity)과 SAE 접근법의 차이

관점	Weight Sparsity (이 논문)	SAE 접근법
모델 학습	처음부터 새로 학습	기존 모델에 적용
회로 완전성	엣지까지 완전히 해석	복잡한 계산은 추상화
실용성	비효율적, 연구용	실제 모델에 적용 가능
회로 크기	수십 개 노드/엣지	수천~수십만 피처

Attribution Graphs와의 관계

최근 Anthropic의 “Attribution Graphs” 연구(Ameisen et al., 2025)도 비슷한 목표를 추구합니다. 그들은 Cross-layer Transcoder를 사용해서 피처 간의 인과 관계를 추적합니다.

그러나 Attribution Graphs는 어텐션 헤드 내부의 계산(Q-K 상호작용)을 완전히 설명하지 못합니다. 이 논문의 Weight-Sparse 접근법은 그런 세부 사항까지 드러낼 수 있다는 장점이 있습니다.

---

🎓 결론: 왜 이 연구가 중요한가?

AI 안전성을 위한 기초

이 연구는 단순한 학술적 호기심이 아닙니다. AI 시스템이 점점 더 강력해지면서, “왜 그런 결정을 내렸는지”를 이해하는 것은 안전성의 핵심이 됩니다.

예를 들어, AI가 거짓말을 하거나, 유해한 콘텐츠를 생성하거나, 편향된 결정을 내릴 때, 그 “회로”를 찾아내고 수정할 수 있다면 어떨까요? 이 논문은 그런 미래를 향한 중요한 발걸음입니다.

핵심 기여 요약

• ✅ 가중치 희소성이 해석가능성을 획기적으로 향상시킨다는 것을 입증
• ✅ 실제 작업에 대해 인간이 완전히 이해할 수 있는 회로를 추출
• ✅ 회로 이해를 바탕으로 적대적 공격까지 성공적으로 수행
• ✅ 능력-해석가능성 트레이드오프와 스케일링 법칙 규명
• ✅ Bridge를 통해 기존 Dense 모델 해석의 가능성 제시

이 분야에 관심 있는 대학원생들에게 몇 가지 시사점을 드리자면:

• 희소 학습 알고리즘 개선: 현재 방법은 매우 비효율적입니다. 더 좋은 최적화 기법이 필요합니다.
• 자동화된 회로 분석: 현재 회로 해석은 수작업입니다. 자동화 도구 개발 기회가 있습니다.
• Bridge 방법론 확장: 더 크고 복잡한 모델에 Bridge를 적용하는 연구.
• 안전성 관련 회로 연구: 거부, 속임수, 목표 추구 등 안전성 관련 행동의 회로를 분석.

⛏️ Dig Review

⛏️ Dig — Go deep, uncover the layers. Dive into technical detail.

들어가기: AI 속 회로를 이해하기 어려운 이유

요즘 거대 언어 모델(Large Language Model)들은 마치 마법처럼 자연스럽게 말을 만들어내지만, 속마음은 여전히 까만 상자 같아요. 모델 안에서 무슨 알고리즘이 돌아가고 있는지 사람 눈에는 보이지 않거든요. 예를 들어, 트랜스포머 모델 속 뉴런(neuron)들이 언제, 왜 활성화되는지 예측하기 어렵고, 각 뉴런이 어떤 개념을 나타내는지도 모르기 때문에 이해가 어려워요. 이런 복잡함의 한 원인은 중첩(superposition) 문제인데요, 간단히 말해 밀집 모델(dense model)에선 하나의 뉴런이 여러 가지 특징을 얽어서 표현해요. 그러다 보니 뉴런의 동작이 마치 겹겹이 포개진 그림처럼 복잡해져요. 이런 상태에선 우리가 특정 뉴런이나 연결 하나하나가 무슨 역할을 하는지 직관적으로 이해하기 힘들죠.

기계론적 해석(Mechanistic Interpretability) 분야의 목표는 이 까만 상자를 열어 모델 내부의 회로를 사람이 이해할 수 있는 형태로 밝히는 거예요. 하지만 일반적인 밀집 신경망에서는 수많은 가중치가 복잡하게 얽혀 있어서, 마치 거미줄처럼 꼬인 회로를 분석해야 하는 어려움이 있어요. 그래서 최근 연구들은 뉴런들의 표현을 억지로 희소하게 만들기 위해 특수한 기법들을 쓰기도 했지만, 여전히 완전히 이해하긴 어려웠어요.

그럼 어떻게 하면 모델 속 회로를 더 쉽게 이해할 수 있을까요? 이번에 OpenAI 연구진은 참신한 생각을 해냈어요. 아예 모델을 만들 때부터 "선 정리"를 잘해보자는 거예요. 즉, 모델 속 뉴런들을 서로 다닥다닥 연결하지 말고, 필요한 최소한으로만 이어주는 거죠. 이렇게 하면 모델이 학습을 할 때부터 각 뉴런이 딱 한두 가지 역할만 하게 유도할 수 있지 않을까요? 이 아이디어가 바로 가중치 희소화(weight sparsity)예요. 오늘 소개할 논문 "Weight-sparse transformers have interpretable circuits"는 이렇게 가중치를 거의 0으로 만들어 버린 희소 트랜스포머 모델을 훈련했더니, 정말로 내부에 사람이 이해하기 쉬운 작은 회로들이 나타났다는 걸 보여줍니다!

가중치 희소 트랜스포머란 무엇일까?

우선 "가중치 희소화된 트랜스포머"가 뭔지부터 알아볼게요. 일반적인 트랜스포머 모델에서는 각 층의 뉴런들이 수많은 다른 뉴런들과 연결되어 있어요. 예를 들어, 하나의 뉴런이 몇 천 개의 입력 채널과 연결될 수도 있어요. 이런 상황을 초등학생 눈높이로 비유해 볼게요. 한 교실에 학생이 100명 있다고 상상해요. 밀집 모델이라면 그 100명이 모두 서로 친구 맺고 얘기하는 거예요. 그러면 누가 누구에게 정보를 주었는지 추적하기 정말 어렵겠죠! 반대로 희소 모델에서는 각 학생이 딱 2~3명 친구만 사귀라고 제한하는 거예요. 그러면 정보가 퍼지는 경로가 훨씬 단순해지겠죠? 누구한테 물어보면 그 사람이 들은 이야기를 추적하기 쉬워지는 것처럼요. 희소 트랜스포머도 마찬가지예요. 각 뉴런이 극소수의 뉴런에만 연결될 수 있도록 아예 학습 과정에서 강제한 모델이죠.

具체적으로, 이 논문에서는 훈련 중 매 단계마다 가중치 행렬(weight matrix)의 아주 큰 값들 몇 개만 남기고 나머지는 전부 0으로 만들어버리는 방법을 썼어요. 예를 들어 100개의 연결 중 1~5개 정도만 남겨두고 95개 이상은 싹 다 0으로 만들어버리는 식이에요. 그러니까 각 뉴런은 진짜 몇 안 되는 경로로만 신호를 주고받게 됩니다. 이런 식으로 해서 전체 모델의 가중치 중 95~99%가 0인 아주 드문드문 연결된 신경망을 만들었어요. 수학적으로는 L0 노름 제약을 준 거라고 하는데, 쉽게 말해 "0이 아닌 가중치의 개수를 줄여라!"라는 규칙을 걸고 훈련시킨 거예요. 또한 이렇게 대부분 연결을 죽여버리면 학습이 불안정할 수 있어서, 학습률을 조절하는 특수 스케줄(sharkfin learning rate) 같은 테크닉도 썼어요. 모델이 배우는 데이터셋은 Python 코드예요. (재미있게도, 모델이 코드 상에서 여닫는 괄호나 따옴표 같은 규칙을 익혀야 하니까, 회로 분석이 더 확실히 드러나게 좋은 선택이에요.)

그림으로 한번 볼까요? 아래 그림은 연구진이 제안한 훈련 및 해석 과정을 한눈에 보여줘요. 먼저 가중치 희소화 제약을 걸고 트랜스포머를 새로 훈련시킵니다. 그런 다음 이 훈련된 희소 모델에 대해, 연구진이 준비한 몇 가지 단순한 과제(task)를 수행하게 해요. 각 과제에 대해서 모델 안에서 그 과제를 해결하는 데 정말 필요한 부분만 남기고 나머지 뉴런과 연결은 다 끊어버립니다. 이렇게 해서 과제별로 최소 회로를 뽑아내는 거죠.

그림 1: 연구진의 전체 실험 과정. 우선 가중치 희소화를 적용하여 희소 트랜스포머 모델을 훈련합니다. 그리고 미리 정해둔 간단한 작업들을 모델에게 주고, 그 작업을 수행하는 데 꼭 필요한 뉴런들과 연결만 남기고 나머지는 평균값으로 대체(일종의 비활성화)하는 방법으로 잘라냅니다. 이렇게 하면 각 작업을 위한 모델 속 전용 회로를 얻을 수 있어요. (※ 그림에서 print("Circuit sparsity ...") 같은 코드는 모델이 실제로 문자열을 출력하는 예시를 보여준 것입니다.)

회로 찾기: 필요한 부분만 남기고 잘라내기

그렇다면 위에서 말한 "필요한 부분만 남기고 나머진 끊어낸다"는 걸 어떻게 했을까요? 연구진은 모델이 어떤 특정 작업을 할 때 쓰는 회로만 뽑아내기 위해, 일종의 가지치기 알고리즘(pruning)을 사용했어요. 쉽게 말해 모델 속 뉴런 하나하나에 스위치를 달았다고 상상해봅시다. 스위치를 끄면 그 뉴런은 전달을 못 하게 되고요. 처음엔 모든 뉴런의 스위치를 켜 둬서 완전한 모델로 작업을 해봐요. 그러다 "이 뉴런은 안 써도 되겠는데?" 싶은 게 있으면 스위치를 꺼 보는 거예요. 그래도 모델이 그 작업을 잘 해내면, "아, 이 뉴런은 필요 없구나!" 하고 영구히 제거하는 거죠. 이렇게 최대한 많은 뉴런을 꺼서 없애되, 정말 중요한 뉴런들은 끝까지 켜두면 결국 최소한의 뉴런과 연결만 남은 작은 회로가 나오겠죠? 바로 이런 원리의 알고리즘이에요.

물론 실제로는 더 똑똑한 방법을 썼어요. 뉴런 단위로 0/1 마스크를 둬서 "이 뉴런 살릴까 말까"를 기계적으로 학습시킨 거예요. 그리고 아예 꺼버리는 대신, 그 뉴런이 평균적으로 내뿜던 값(평균 활성화)을 넣어서 모델을 굴려봤어요. 이렇게 하면 해당 뉴런의 효과만 제거되고, 완전히 0으로 날리는 것보다 모델 성능에 덜 충격을 주거든요. 그래서 이 방법을 평균 제거(mean ablation)라고 해요. 결국 남은 뉴런들과 연결로 이루어진 작은 회로(circuit)를 찾아낼 수 있었습니다. 이걸 회로 발견(circuit discovery)라고 부를게요.

그럼 이 회로의 크기(남은 뉴런과 연결의 수)가 곧 모델 해석 용이성의 척도가 됩니다. 왜냐하면 회로가 작을수록 사람이 들여다보면서 이해하기 쉽잖아요. 예컨대 수백 개 뉴런이 복잡하게 연결된 회로보다, 열댓 개 뉴런이 간단히 연결된 회로가 훨씬 무슨 역할을 하는지 설명하기 쉽겠죠. 이 논문에서는 그래서 "인터프리터빌리티(해석 가능성)"를 회로 크기로 정의했어요. 작은 회로 = 높은 해석 가능성인 셈이죠.

연구진은 모델을 평가하기 위해 간단한 판단 문제들을 여러 개 만들었어요. 각 문제는 모델에게 두 가지 선택지 중 하나를 고르게 하는 형태예요. (예를 들면, 따옴표를 하나만 열고 문장을 끝냈을 때, 다음에 닫는 따옴표를 출력해야 맞을까요 아니면 다른 문자를 출력해야 할까요 같은 문제를 낸 거예요.) 모델이 정답을 맞히는 동안 내부에서는 이 둘 중 하나를 고르는 계산 회로가 돌아가겠죠. 그 성공적인 회로만 쏙 뽑아낸 것입니다. 그리고 나서 그 회로를 정말 우리가 완전히 이해할 수 있는지 면밀히 분석했어요.

희소 모델 vs. 밀집 모델: 더 작은 회로 = 더 잘 이해되는 회로

이제 핵심 질문으로 돌아와 봅시다: “가중치 희소화가 왜 회로를 이해하기 쉽게 만들어줄까?” 이에 대한 답을, 연구진은 밀집 모델과의 비교 실험으로 보여줍니다. 똑같이 Python 코드를 학습했지만 가중치 희소화 제약을 쓰지 않은 일반 트랜스포머(즉 밀집 모델)를 하나 준비하고, 우리 희소 모델과 성능이 비슷한 수준이 되도록 맞춰요. 두 모델이 문제를 푸는 능력(capability)은 비슷하게 만든 후에, 아까 말한 가지치기 알고리즘으로 각각 최소 회로를 찾아냅니다. 그리고 그 회로의 크기(남은 뉴런/연결 수)를 비교했어요.

결과는 어땠을까요? 희소 트랜스포머 쪽이 훨씬 더 작은 회로만으로 동일한 문제를 풀 수 있었어요. 아래 그래프를 보면, 세로축은 문제 풀이 성능(작을수록 좋음)이고 가로축은 찾아낸 회로의 크기(작을수록 해석하기 좋음)예요. 주황색 선은 희소 모델, 파란색 선은 밀집 모델인데요. 같은 성능 수준에서 희소 모델은 밀집 모델보다 회로 크기가 약 16분의 1밖에 안 돼요! 이를테면, 밀집 모델은 특정 정확도를 내려면 회로에 100개의 요소가 필요했다면, 희소 모델은 겨우 6개 정도 요소만으로도 해내는 셈이에요. 이건 엄청난 차이죠.

그림 2: 희소 모델은 밀집 모델보다 훨씬 작은 회로로도 같은 성능을 달성합니다. 세로축은 태스크 손실(작을수록 정확함)이고 가로축은 프루닝 후 남은 회로의 크기를 나타냅니다. 파란색 밀집 모델에 비해 주황색 희소 모델은, 동일한 성능 수준에서 필요한 회로 규모가 현저히 작습니다. 구체적으로 모든 태스크에 대해 평균적으로 16배나 작은 회로를 보여주었어요. 다시 말해, 희소화된 모델일수록 회로가 단순해져서 사람이 이해하기 쉬운 구조가 된다는 실증적 근거예요.

왜 이런 차이가 생길까요? 희소 모델에서는 각 뉴런이 오직 몇 개의 경로만 읽고 쓰다 보니, 모델이 굳이 복잡하게 이것저것 얽어쓰지 않게 됩니다. 하나의 개념을 표현하려고 불필요하게 많은 뉴런을 동원하거나, 여러 뉴런에 걸쳐 분산시킬 이유가 줄어드는 거죠. 반면 밀집 모델은 가용한 연결이 너무 많아서 한 뉴런에 여러 의미가 겹치는 중첩 현상이 심하고, 회로를 찾더라도 여기저기 흩어진 큰 회로가 나타나는 거예요. 희소화로 일종의 규율을 강제했더니, 모델이 스스로 "한 뉴런, 한 역할" 식으로 솔루션을 찾아간 셈입니다.

연구진은 이 회로들이 정말 정확히 그 작업에 필요한 기능만 담당하는지도 검증했어요. 찾은 회로의 뉴런들만 남기고 나머지 모두를 다 평균값으로 대체해버려도 (즉 회로 이외를 몽땅 무력화시켜도) 모델의 해당 작업 성능은 거의 그대로였어요. 그런데 딱 그 회로의 뉴런들만 제거하면 모델이 작업을 완전히 망쳤습니다. 이건 무슨 뜻일까요? 네, 찾아낸 작은 회로가 그 작업을 수행하는 데 꼭 필요하고도 충분한 부분이란 뜻이에요. 즉, 회로 해석의 정확성까지 입증한 거죠. 작은 회로를 이해하면 모델의 그 행동을 온전히 이해했다고 할 수 있으니까요.

하지만 이 접근에도 한 가지 고민이 있어요. 이렇게 희소 모델을 훈련하는 게 매우 비효율적이라는 거예요. 연결이 대부분 없으니, 원하는 성능을 내기까지 데이터를 훨씬 오래 학습해야 했어요. 또 희소 모델은 실제 서비스에 쓰기엔 속도가 느릴 수도 있고요 (행렬 대부분이 0이라 계산 낭비가 크거든요). 그러니 지금 상태로는 최신 거대 모델 규모로 희소 모델을 만들긴 어렵습니다 (연구에서도 수천만 개 정도의 비영(zero가 아닌) 파라미터까지 실험했는데, 더 크게 하는 건 도전 과제라고 해요). 그래도 이 연구는 "성능 좋은 모델을 만드는 것과 해석하기 쉬운 모델을 만드는 것 사이에 절충점이 있다"는 걸 처음으로 정량적으로 보여준 사례예요. 다음에 설명할 규모 확장 실험에서는 이 절충점을 어떻게 좀 더 개선할 수 있는지도 다룹니다.

모델 크기와 해석 가능성의 줄다리기

그렇다면 모델의 크기(파라미터 수)를 키우면 해석 가능성에는 어떤 영향이 있을까요? 일반적으로 모델이 크고 복잡해지면 더 깊고 난해한 회로가 생길 거라고 생각하기 쉬워요. 하지만 연구 결과는 꼭 그렇지만은 않다는 흥미로운 사실을 보여줍니다.

연구진은 여러 크기의 희소 모델을 만들어 비교했어요. 예를 들어 전체 파라미터 수(모델 폭과 깊이)를 달리하면서, 희소율(전체 중 0이 아닌 가중치 개수)도 다양하게 조절했어요. 그렇게 해서 "모델 능력 vs. 해석 가능성" 사이의 관계 곡선을 살펴봤습니다. 아래 그림처럼, 가로축은 모델의 학습 성능(프리트레인 손실)이고 세로축은 찾은 회로의 크기예요. 각 곡선 하나하나는 모델의 총 파라미터 규모를 나타내고, 곡선 위 점들은 희소화 정도(L0 값)를 달리한 경우들이에요. 그래프에서 왼쪽 아래 방향으로 갈수록 더 성능 좋고 회로 작아서 이상적인 상태예요.

그림 3: 모델 규모와 희소화 정도에 따른 성능-해석가능성 트레이드오프. 색깔별 곡선은 모델의 총 크기(파라미터 수)를 나타내고, 곡선 상의 점들은 희소 모델의 비영 파라미터 수(L0)를 변화시킨 케이스들입니다. 곡선이 왼쪽 아래로 갈수록 더 좋습니다. 보라색/파란색 곡선 (큰 모델들)이 주황/노랑 (작은 모델들)보다 왼쪽 아래 위치로 더 내려가 있죠. 이는 모델을 크게 만들면 동일한 희소율에서도 더 높은 성능과 작은 회로를 동시에 얻을 수 있음을 뜻합니다. 다시 말해, 모델 폭을 늘리면 해석 가능성을 해치지 않으면서도 오히려 향상시킬 수 있다는 거예요. 이 발견은 "모델이 커질수록 더 해석 불가능해질 것"이라는 일반적인 직감을 뒤집는 흥미로운 결과입니다.

하지만 주의해야 할 점이 있어요. 그래프를 보면 모델이 커져도 어느 정도까지는 좋다가, 한계를 넘어가면 곡선이 덜 좋아질 수도 있어요. 아직 수억~수십억 개 규모의 파라미터까지는 희소 모델로 검증하기 어려워서, 이 방법이 아주 대규모 모델에도 통할지는 미지수예요. 그럼에도 중요한 건, 적당한 규모 확대는 오히려 해석 가능한 회로를 얻는 데 유리할 수 있다는 점이 확인된 거예요. 앞으로 더 큰 희소 모델을 만들 기술만 뒷받침된다면, 성능과 해석력 둘 다 잡는 모델도 꿈은 아닐지 몰라요.

실제 회로 예시 살펴보기: 작지만 똑똑한 뉴런들

말로만 들으면 감이 안 올 수 있으니, 실제로 모델 속에서 찾아낸 회로들이 어떻게 생겼는지 예를 들어 볼게요. 정말 신기하게도, 희소 트랜스포머에서 뽑아낸 회로들은 우리가 직접 이해할 수 있을 만큼 간단한 구성이었어요. 게다가 각 부분이 담당하는 기능도 사람 입장에서 직관적으로 납득이 갔습니다.

예시 1: 따옴표 닫기(문자열 마무리) 회로

첫 번째 예시는 문자열을 끝까지 닫아주는 작업이에요. 파이썬 코드에서 문자열을 " "나 ' '로 열었으면, 나중에 그에 맞는 닫는 따옴표로 끝내야 하잖아요. 희소 모델에게 print("Hello, world 같은 입력을 주고, 올바르게 "Hello, world"로 끝맺는지를 묻는 식의 작업을 생각해봅시다. 모델이 이걸 제대로 해낸다면, 내부에 여는 따옴표를 인식하고 대응되는 닫는 따옴표를 출력하는 논리가 있어야겠죠.

실제로 희소 모델을 프루닝해서 이 작업의 회로를 뽑아보니, 딱 두 개의 MLP 뉴런과 하나의 어텐션 헤드만으로 구성된 작은 회로가 나타났어요! 믿기 어려울 정도로 단순한데요, 이 각각이 무슨 역할을 하는지도 그림을 보면 바로 알 수 있습니다. 아래 그림은 그 "따옴표 닫기" 회로의 상세도예요. 총 12개의 노드(뉴런 또는 채널)와 그 사이 9개의 연결(엣지)만을 보여주고 있는데, 이게 이 작업을 거의 완벽히 수행하는 데 충분한 전체 회로라고 합니다.

그림 4: 문자열 따옴표를 올바르게 닫아주는 회로의 구조. 이 작은 회로 안에서 딱 두 개의 MLP 뉴런(사각형 모양)과 하나의 어텐션 헤드(원 모양)가 중요한 역할을 합니다. 하나의 뉴런은 입력 토큰 스트림에서 따옴표가 등장했는지 감지하는 "따옴표 감지기" 역할을 하고, 또 다른 뉴런은 그 따옴표가 single인지 double인지 구분하는 "따옴표 종류 분류기" 역할을 해요. 이 두 신호는 어텐션 메커니즘을 통해 사용되는데, 어텐션 헤드는 문장의 끝 부분에서 앞서 감지된 정보들을 참조하여 알맞은 닫는 따옴표를 출력하도록 합니다. 요약하면, 뉴런 하나가 따옴표 위치를 찝어주고, 또 하나는 따옴표 종류를 알려주면, 어텐션 헤드가 "아, 여기는 따옴표를 닫아줘야겠구나!" 하고 정답 따옴표를 내놓는 것이죠. 놀랍게도 이 회로의 동작 원리를 사람이 단계별로 설명할 수 있게 된 거예요. 실제로 연구진은 이 회로의 이해를 바탕으로, 모델을 속일 수 있는 특수한 입력도 설계해봤어요. 예컨대 모델이 따옴표를 제대로 닫지 못하도록 교묘하게 함정을 판 입력을 만들어본 거죠. 그랬더니 예측대로 모델이 오답을 내더라는 겁니다! 이처럼 모델 내부를 이해하면 그 모델의 약점까지도 예상할 수 있다는 걸 보여주는 재미있는 사례였어요.

예시 2: 괄호 깊이 세기 회로

두 번째로 살펴볼 회로는, 여러 겹으로 중첩된 괄호의 깊이를 세는 작업이에요. 파이썬 코드나 수학 수식에서 괄호 [ ]를 여닫는 규칙을 생각해보면, 괄호를 여러 번 열면 그만큼 닫아야 하죠. 예를 들어 [[5, 3]라는 입력이 있으면 ]가 하나 더 필요하고, [[[ ]처럼 세 겹으로 열었으면 세 겹 닫아야 맞아요. 모델이 이러한 중첩 깊이를 추적해서 맞는 개수의 닫는 괄호를 출력하는지를 테스트하는 과제입니다.

희소 모델에서 이 기능을 담당하는 회로를 뽑아 분석한 결과, 상당히 흥미로운 알고리즘이 그 안에 구현되어 있었어요. 아래 그림은 논문에 소개된 "괄호 깊이 세기" 회로 개략도예요. 얼핏 복잡해 보이지만, 핵심 아이디어는 이렇습니다: 어텐션 헤드가 문장 전체를 보며 "여는 괄호" 신호들을 모아서 한 군데로 요약해요. 예를 들어 문장에 [가 세 번 나오면, 어텐션이 그걸 캐치해서 "지금 깊이 3이야!"라는 식의 값을 잔차 스트림의 특정 채널에 저장해둡니다. 그리고 나중에 그 값을 읽어서 필요한 ]의 개수를 결정하는 거죠. 쉽게 말해, 모델이 열린 괄호의 개수를 세어 저장해뒀다가, 닫는 시점에 그 숫자만큼 닫는 괄호를 출력하는 방식의 회로를 학습한 거예요. 이 과정에는 여러 개의 뉴런과 두 개 정도의 어텐션 헤드가 협업하는 두 단계 알고리즘이 숨어 있었는데요, 사람 연구자가 그 구조를 완전히 해석해서 설명할 수 있었습니다. 이것도 대단하죠!

그림 5: 중첩된 괄호 깊이를 추적하는 회로의 개념도. 괄호 깊이 회로는 2개의 어텐션 헤드와 몇 개의 뉴런이 협력하여 동작합니다. 먼저 한 어텐션 헤드가 "여는 괄호 감지기" 역할을 해서 입력에서 [ 토큰들을 찾으면, 그 정보를 Residual(잔차) 채널에 합산해요. 이 값은 현재 괄호가 몇 겹인지 나타내는 "중첩 깊이" 신호가 됩니다. 이후 다른 어텐션 헤드나 뉴런들이 이 깊이 신호를 평균내거나 임계값에 따라 해석해서, 최종 출력에서 필요한 개수의 ]를 내보내도록 돕습니다. 결국 모델은 괄호를 여는 만큼 닫아주는 규칙을 정확히 회로화하여 구현한 거예요. 이런 복잡한 기능도 희소 모델에서는 분해 가능한 몇 단계 논리회로로 나타났고, 우리는 그것을 하나하나 추적하며 이해할 수 있었어요.

그 밖의 발견: 변수 타입 추적 회로 등

이 논문에서 분석한 회로는 위 두 가지뿐만이 아니에요. 또 다른 예시로, 어떤 변수(current)가 집합인지 문자열인지 추적하는 회로도 있었어요. 예를 들어 코드에서 current = set()인지 current = ""인지에 따라, 모델이 나중에 다르게 처리해야 하는 상황을 가정해 볼 수 있죠. 희소 모델은 이를 위해 두 단계짜리 어텐션 회로를 사용했는데, 먼저 한 어텐션 헤드가 current라는 변수가 등장한 곳을 기억하고, 다음 층의 다른 헤드가 그 변수의 타입 표식(집합이면 {}, 문자열이면 "" 이런)을 읽어와서, 최종적으로 변수의 타입에 맞는 처리를 결정하는 식이었어요. 이 회로에 사용된 뉴런과 채널이 총 100개 정도 되고 꽤 컸지만, 그래도 사람이 해석 가능할 정도로 논리적으로 분해할 수 있었다고 합니다.

기존 모델에도 적용할 수 있을까?

희소 모델은 이렇게 멋지게 해석 가능한 회로를 보여줬지만, 현실적으로 지금 돌아가는 최첨단 대형 AI 모델들은 대부분 밀집 모델이에요. 그렇다면 우리가 이미 잘 활용하고 있는 GPT-같은 밀집 거대 모델 내부도 이런 식으로 해석 가능하게 만들 방법이 있을까요?

연구진은 이에 대한 첫 걸음으로 브릿지(bridge)라는 개념을 제안했어요. 간단히 말하면, 밀집 모델과 희소 모델을 연결시켜주는 작은 가교 신경망을 두고, 둘 사이의 표현을 호환시키는 거예요. 희소 모델 쪽은 우리가 회로를 해석할 수 있으니, 그 정보를 브릿지를 통해 밀집 모델로 투영해보는 거죠. 예를 들어, 희소 모델에서 "따옴표 종류 분류기" 뉴런을 찾았다면, 브릿지를 통해 밀집 모델에서도 비슷한 역할을 하는 활성 패턴을 찾아볼 수 있다는 겁니다. 실제 실험에서, 희소 모델에서 뉴런 하나를 조작해서 특정 특징을 바꾸면, 브릿지를 거쳐 연결된 밀집 모델의 출력 행동도 예상대로 바뀌는 초기 성공 사례를 보였어요. 물론 아직은 개념 증명 수준이지만, 이게 발전하면 기존의 복잡한 모델들도 부분부분 해부해볼 수 있는 도구가 될 수 있겠죠?

마무리: 간단한 회로, 큰 통찰

이 연구는 “애초에 이해하기 쉬운 모델을 만들면 어쩌면 답이 보일지도 몰라!”라는 역발상이 얼마나 놀라운 결과를 가져오는지 보여줬어요. 요약하자면:

• 가중치 희소화를 통해 뉴런 연결을 대폭 줄인 트랜스포머를 훈련하니, 모델이 스스로 더 모듈화되고 해석 가능한 구조를 갖추게 되었어요. 이는 마치 복잡하게 엉킨 이어폰 줄을 처음부터 가지런히 정리하면서 쓰는 느낌이에요.
• 이렇게 만든 희소 모델은 동일한 능력의 밀집 모델보다 훨씬 작은 회로로 태스크를 해결했고, 그만큼 이해하기 쉬운 청사진을 제공했습니다. 심지어 그 회로가 정말 필요한 부분임도 실험으로 검증했죠.
• 회로 예시 분석을 통해, 모델 내부에 존재하는 자연스러운 개념 단위(예: 따옴표 감지, 괄호 깊이 계산 등)를 직접 확인했어요. 이는 AI가 문제를 풀 때 사람 비슷한 논리 단계로 처리하고 있을 가능성을 시사합니다.
• 모델 크기를 키우면 희소 모델의 성능과 해석가능성 모두 향상될 수 있다는 결과는, 해석 가능 AI 연구의 새로운 길을 보여줍니다. 꼭 작은 모델만 해석할 수 있는 게 아니라, 큰 모델도 설계만 잘 하면 투명하게 만들 수 있다는 희망이죠.
• 마지막으로, 완전히 희소 모델로 훈련하지 않더라도 브릿지 기법처럼 현재의 강력한 밀집 모델을 부분적으로라도 이해해보려는 시도가 이어지고 있어요. 장기적으로는 생산 현장에서 쓰이는 AI에도 이런 해석 가능한 회로 개념을 접목할 수 있을지 모릅니다.

이번 논문의 가장 큰 의의는, “해석 가능성 대 성능”이라는 오랜 딜레마를 정면돌파할 새로운 패러다임을 제시했다는 데 있어요. 물론 지금은 희소 모델을 훈련하는 비용이 크고, 완전히 실용화하려면 갈 길이 멉니다. 하지만 결과로 얻어진 회로의 명확함을 보면, 앞으로 AI를 투명하게 만드는 연구 방향에 강렬한 영감을 준 것만은 확실합니다. 우리가 AI의 내부 회로를 이해하고 신뢰할 수 있게 되는 미래가 조금 더 가까워진 것 같지 않나요? 🔍🤖