서론

최근 LLM(Large Language Model) 시장에서 Anthropic의 Claude 3 모델 계열, 특히 그 이면에 있는 것으로 추정되는 ‘Mythos’ 아키텍처는 많은 연구자들의 호기심을 자아내고 있습니다. 하지만 가장 성능이 뛰어난 폐쇄형(Closed-source) 모델들은 대부분 ‘블랙박스’ 상태로 운영됩니다. 우리는 단지 API를 통해 결과물을 확인할 뿐, 그 모델이 어떻게 200k 토큰 이상의 긴 컨텍스트를 효율적으로 처리하며, 높은 추론 능력을 유지하는지에 대한 구조적인 비밀은 접근하기 어렵습니다.

이러한 정보의 비대칭은 오픈소스 진영의 발전을 저해하는 요인이 되기도 합니다. 바로 이 지점에서 OpenMythos 프로젝트는 단순한 호기심을 넘어선 중요한 실험적 가치를 지닙니다. 이 프로젝트는 누군가 유출한 가중치(Weights)를 사용하는 것이 아니라, 공개된 논문과 아카이브(arXiv)의 연구 성과들을 토대로 Mythos로 추정되는 아키텍처를 이론적으로 재구성(Reverse Engineering)하려는 시도입니다. 본 글에서는 이러한 재구성이 기술적으로 어떤 의미를 가지며, 실제로 어떤 설계 선택(Design Choice)이 포함되어 있는지 심도 있게 분석해 보겠습니다.

본론

Mythos 아키텍처의 핵심 가설: Hybrid Attention

OpenMythos의 핵심은 Claude 계열에서 사용되는 것으로 추정되는 하이브리드 어텐션(Hybrid Attention) 메커니즘을 재현하는 데 있습니다. 일반적인 트랜스포머 모델은 모든 토큰 간의 관계를 계산하는 Dense Attention을 사용하여, 시퀀스 길이($N$)가 길어질수록 계산 복잡도가 $O(N^2)$로 증가하는 문제를 겪습니다.

Mythos 아키텍처로 추정되는 구조는 이를 해결하기 위해 **Local Sliding Window Attention(국소 윈도우 어텐션)**과 **Global Attention(전역 어텐션)**을 결합하는 방식을 채택했을 가능성이 큽니다. 이는 Longformer나 BigBird와 유사한 접근 방식이지만, 특정 작업에 최적화된 방식으로 두 메커니즘을 융합했다는 가설 하에 설계됩니다.

아래 다이어그램은 이론적으로 재구성된 OpenMythos의 데이터 흐름을 간단화하여 나타낸 것입니다.

1
2
3
4
5
6
7
8

graph TD
    Input[Input Sequence] --> Split[Context Splitter]
    Split --> LocalStream[Local Window Attention]
    Split --> GlobalStream[Global Sparse Attention]
    LocalStream --> FFN[Feed Forward Network]
    GlobalStream --> FFN
    FFN --> Residual[Residual Connection & Norm]
    Residual --> Output[Contextualized Output]

이 구조는 전체 토큰 중 일부는 전체 컨텍스트를 볼 수 있게 하고(Global), 나머지 토큰들은 근처의 토큰들만 주시하게 함(Local)으로써, 계산 비용을 선형적($O(N)$)으로 줄이면서도 장거리 의존성(Long-range dependency)을 유지합니다.

기술적 구현: PyTorch를 통한 모듈 구성

이제 가설로 세운 아키텍처를 실제 코드로 구현해 보겠습니다. 이는 OpenMythos의 핵심 컴포넌트인 Hybrid Attention 레이어를 PyTorch로 작성한 예제입니다. 실제 프로덕션 코드보다는 이해를 돕기 위해 단순화된 형태입니다.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

import torch
import torch.nn as nn
import torch.nn.functional as F
from math import sqrt

class MythosHybridAttention(nn.Module):
    def __init__(self, config):
        super().__init__()
        self.num_heads = config.num_heads
        self.head_dim = config.hidden_size // config.num_heads
        self.window_size = config.window_size  # Local attention window size
        
        # Q, K, V projections
        self.qkv = nn.Linear(config.hidden_size, 3 * config.hidden_size)
        
        # Output projection
        self.out = nn.Linear(config.hidden_size, config.hidden_size)
        
        # Global token indices (e.g., [CLS] or specific markers)
        self.register_buffer('global_indices', torch.tensor([0])) 

    def forward(self, x):
        B, T, C = x.size() # Batch, Tokens, Channels
        
        # 1. QKV Split
        qkv = self.qkv(x).reshape(B, T, 3, self.num_heads, self.head_dim).permute(2, 0, 3, 1, 4)
        q, k, v = qkv[0], qkv[1], qkv[2] # (B, H, T, D)
        
        # 2. Scale
        scale = 1.0 / sqrt(self.head_dim)
        
        # 3. Efficient Sparse & Local Calculation (Simplified for logic)
        # In a real implementation, this would use FlashAttention or block-sparse ops.
        # Here we demonstrate the logical mask combination.
        
        # Local Mask (Sliding Window)
        local_mask = torch.ones(T, T, device=x.device).tril(diagonal=self.window_size).triu(diagonal=-self.window_size)
        local_mask = local_mask.masked_fill(local_mask == 0, float('-inf'))
        
        # Global Mask (Specific tokens attend to all)
        global_mask = torch.zeros(T, T, device=x.device)
        global_mask[self.global_indices, :] = 0 # Global tokens see everything
        global_mask[:, self.global_indices] = 0 # Everyone sees global tokens
        
        # Combine masks
        combined_mask = local_mask + global_mask
        
        # 4. Attention Scores & Softmax
        attn = (q @ k.

1
2
3
4
5
6
7

transpose(-2, -1)) * scale
        attn = attn + combined_mask # Apply mask
        attn = F.softmax(attn, dim=-1)
        
        # 5. Aggregation
        out = (attn @ v).transpose(1, 2).reshape(B, T, C)
        return self.out(out)

이 코드는 단순한 예시이지만, OpenMythos가 추구하는 방향성을 명확히 보여줍니다. local_mask는 계산 범위를 제한하여 효율성을 높이고, global_mask는 중요한 토큰(시스템 프롬프트나 중간 결론 등)이 전체 문맥을 파악할 수 있게 하여 추론 능력을 보존합니다.

아키텍처 비교 및 성능 분석

기존의 표준 Transformer(Decoder-only) 구조와 OpenMythos에서 재구성된 Hybrid 구조를 비교하면, 왜 최신 LLM들이 이러한 변형을 추구하는지 알 수 있습니다. 아래 표는 두 아키텍처의 이론적 특성을 비교한 것입니다.

| 비교 항목 | Standard Dense Attention (GPT-style) | OpenMythos Hybrid Attention (Mythos-style) | | :— | :— | :— | | 시간 복잡도 | $O(N^2)$ (Quadratic) | $O(N)$ (Linear - approximately) | | 메모리 사용량 | Context 길이에 따라 급격히 증가 | 윈도우 크기에 의해 제한됨 | | 장거리 의존성 | 완벽하게 보존 (Infinite theoretically) | Global 토큰을 통해 부분적으로 보존 | | 추론 속도 | 긴 Context에서 느려짐 | 긴 Context에서도 상대적으로 빠름 | | 주요 용도 | 범용적인 생성 작업 | 긴 문서 요약, RAG, 복잡한 추론 |

표에서 볼 수 있듯이, Hybrid Attention은 완벽한 전역 정보를 포기하는 대신 효율성을 극대화합니다. 특히 RAG(Retrieval-Augmented Generation) 시스템에서 긴 문서를 처리할 때, 모델이 문서 전체를 세밀하게 읽는 것보다, 핵심 문장(Global token)을 중심으로 주변 문맥(Local window)을 파악하는 것이 훨씬 효과적일 수 있습니다.

실무 적용 가이드: MLOps 관점

연구자로서 OpenMythos 아키텍처를 이해했다면, 이를 실제 서빙 환경에 적용하기 위한 단계별 가이드가 필요합니다. 단순히 모델 구조를 바꾸는 것을 넘어, 훈련과 추론 전략을 수정해야 합니다.

1. 데이터 전처리 (Data Packing) * Hybrid Attention을 효율적으로 학습시키기 위해서는 문서를 긴 시퀀스로 패킹(Packing)할 때, Global 토큰으로 지정될 위치(예: 문단의 시작, 문장의 끝)를 미리 마킹해야 합니다. 2. 훈련 전략 (Curriculum Learning) * 짧은 윈도우 사이즈로 시작하여 점차 Global 토큰의 비중을 늘려가는 Curricula Learning 방식을 적용하면 모델이 Local과 Global의 균형을 잡는 데 도움이 됩니다. 3. KV Cache 최적화 * 추론 시, Global 토큰에 대한 KV Cache는 오래 유지되어야 하므로 캐시 관리 로직을 분리하여 구현해야 합니다. 이는 PagedAttention 기술(예: vLLM)과 결합할 때 메모리 절약 효과가 극대화됩니다.

결론

OpenMythos 프로젝트는 “어떤 모델이 Claude를

출처: https://news.hada.io/topic?id=28853