Inception Labs에서 발표한 Mercury는 diffusion 기반의 혁신적인 대규모 언어 모델로, 기존 autoregressive 모델의 한계를 뛰어넘는 초고속 추론 성능을 달성했습니다.

Diffusion 모델이 언어 생성에 가져온 혁신

기존 언어 모델의 한계

전통적인 autoregressive 언어 모델들은 다음과 같은 근본적인 제약사항을 가지고 있습니다:

  • 순차적 생성: 한 번에 하나의 토큰만 생성 가능
  • 지연 시간 증가: 긴 텍스트 생성 시 누적되는 대기 시간
  • GPU 활용 비효율: 병렬 처리 능력을 충분히 활용하지 못함
  • 실시간 응용 제약: 코드 자동완성, 에이전트 워크플로우 등에서 사용자 경험 저하

Mercury의 Diffusion 접근법

Mercury는 병렬 토큰 생성을 통해 이러한 문제를 해결합니다:

# 기존 Autoregressive 방식
for i in range(sequence_length):
    token = model.generate_next_token(context)
    context.append(token)  # 순차적 생성

# Mercury Diffusion 방식
noisy_tokens = initialize_random_noise(sequence_length)
for step in range(diffusion_steps):
    # 모든 토큰을 동시에 개선
    noisy_tokens = model.denoise_all_tokens(noisy_tokens)

Mercury Coder 모델 패밀리

모델 구성

Mercury Coder Mini

  • 속도 특화: 1,109 tokens/sec (H100 GPU 기준)
  • 용도: 실시간 코드 자동완성, 빠른 프로토타이핑
  • 품질: 오픈소스 속도 최적화 모델들을 상회하는 성능

Mercury Coder Small

  • 균형잡힌 성능: 737 tokens/sec
  • 품질: 상용 속도 최적화 모델들과 동등한 수준
  • 범용성: 복잡한 코딩 태스크와 추론 작업 지원

기술적 아키텍처

Diffusion 학습 과정

Mercury의 학습은 forward process와 reverse process로 구성됩니다:

Forward Process (노이즈 추가):

깨끗한 텍스트 x → 노이즈가 추가된 z₁ → z₂ → ... → 완전한 노이즈 zₜ

Reverse Process (노이즈 제거):

완전한 노이즈 zₜ → zₜ₋₁ → ... → z₁ → 복원된 텍스트 x

학습 목표 함수:

L(x) = -E_t[γ(t) · E_{z_t~q} log p_θ(x|z_t)]

Transformer 기반 구조

Mercury는 Transformer 아키텍처를 채택하여 다음과 같은 이점을 확보했습니다:

  • 호환성: 기존 최적화 기법들과 완벽 호환
  • 확장성: 대규모 모델 학습에 적합한 구조
  • 효율성: 저수준 연산 최적화 활용 가능

성능 평가 결과

코딩 벤치마크 성능

모델 HumanEval MBPP MultiPL-E 속도 (tokens/sec)
Mercury Coder Mini 88.0 77.1 74.1 1,109
Mercury Coder Small 90.0 76.6 76.2 737
GPT-4o Mini 88.0 74.6 72.0 59
Claude 3.5 Haiku 86.0 78.0 72.3 61
Gemini 2.0 Flash Lite 90.0 75.0 79.5 201

다중 언어 코드 생성

MultiPL-E 벤치마크 결과 (정확도 %):

모델 C++ Java JavaScript PHP Bash TypeScript 평균
Mercury Coder Mini 78.9 74.5 78.9 72.7 56.5 83.2 74.1
Mercury Coder Small 82.0 80.1 83.9 78.3 50.1 82.6 76.2
Codestral 2501 80.1 72.7 83.2 73.9 47.2 83.2 73.4

Fill-in-the-Middle (FIM) 성능

코드 자동완성 시나리오에서의 성능:

모델 Single-Line Random-Span 평균
Mercury Coder Mini 92.9 71.5 82.2
Mercury Coder Small 93.1 76.5 84.8
Codestral 2501 93.0 72.0 82.5
GPT-4o Mini 74.8 47.0 60.9

실제 사용자 평가: Copilot Arena

성능 순위

모델 지연시간 (초) 지연시간 순위 Elo 점수 품질 순위
DeepSeek V2.5 (FIM) 2.07 11 1025 1
Claude 3.5 Sonnet 1.46 8 1003 1
Mercury Coder Mini 0.25 1 993 2
Codestral 0.31 2 992 2
GPT-4o 0.76 5 980 3

주목할 점: Mercury Coder Mini는 품질 2위를 달성하면서 동시에 가장 빠른 속도를 기록했습니다.

핵심 기술적 혁신

병렬 추론 최적화

Mercury의 속도 향상은 다음과 같은 시스템 레벨 최적화에서 비롯됩니다:

동적 배치 처리:

class MercuryInferenceEngine:
    def __init__(self):
        self.dynamic_batcher = DynamicBatcher()
        self.custom_kernels = ParallelInferenceKernels()
    
    def generate(self, prompts, quality_speed_tradeoff=0.5):
        # 품질-속도 트레이드오프 자동 조절
        batch = self.dynamic_batcher.optimize_batch(prompts)
        return self.parallel_diffusion_sample(batch)

커스텀 CUDA 커널:

  • GPU 메모리 대역폭 최대 활용
  • 병렬 디노이징 연산 최적화
  • 동적 배치 크기 조절

호환성 보장

Mercury는 기존 생태계와의 완벽한 호환성을 제공합니다:

OpenAI API 호환:

# 기존 OpenAI API 코드를 그대로 사용 가능
response = openai.ChatCompletion.create(
    model="mercury-coder-mini",  # 모델명만 변경
    messages=[{"role": "user", "content": "Write a Python function"}],
    max_tokens=500
)

Fine-tuning 지원:

  • RLHF (Reinforcement Learning from Human Feedback)
  • DPO (Direct Preference Optimization)
  • 기존 instruction tuning 방법론 적용 가능

실무 활용 사례

코드 자동완성 시스템

class MercuryCodeCompletion:
    def __init__(self):
        self.model = MercuryCoder("mini")
        self.cache = CompletionCache()
    
    async def complete_code(self, context, cursor_position):
        # 25ms 평균 지연시간으로 실시간 완성
        start_time = time.time()
        completion = await self.model.fill_in_middle(
            prefix=context[:cursor_position],
            suffix=context[cursor_position:],
            max_tokens=100
        )
        latency = time.time() - start_time
        
        # 일반적으로 25ms 이하 달성
        assert latency < 0.1, f"지연시간 초과: {latency}s"
        return completion

에이전트 워크플로우

빠른 추론으로 복잡한 다단계 작업을 효율적으로 처리:

class CodeReviewAgent:
    def __init__(self):
        self.mercury = MercuryCoder("small")
    
    async def review_pr(self, code_diff):
        # 병렬로 여러 분석 수행
        tasks = [
            self.mercury.analyze_security(code_diff),
            self.mercury.check_performance(code_diff),
            self.mercury.suggest_improvements(code_diff),
            self.mercury.generate_tests(code_diff)
        ]
        
        # 전체 분석이 몇 초 내에 완료
        results = await asyncio.gather(*tasks)
        return self.consolidate_review(results)

확장성과 미래 전망

스케일링 특성

Mercury 모델들은 크기 증가에 따른 성능 향상을 보여줍니다:

  • Mercury Coder Small이 Mini보다 모든 벤치마크에서 일관되게 우수한 성능
  • Diffusion LLM의 스케일링 법칙 검증
  • 더 큰 모델들의 성능 향상 가능성 시사

응용 분야 확장

현재: 코딩 특화 모델 향후 계획:

  • 일반 텍스트 생성 모델
  • 멀티모달 모델 (코드 + 이미지)
  • 도메인 특화 모델 (과학, 수학, 법률 등)

산업 영향

비용 효율성:

  • 추론 비용 대폭 절감
  • 실시간 서비스 구현 가능
  • Edge 컴퓨팅 환경 활용

사용자 경험 혁신:

  • 지연시간 최소화로 자연스러운 상호작용
  • 복잡한 추론 작업의 실시간 처리
  • 대화형 코딩 도구의 새로운 가능성

기술적 도전과 해결책

Diffusion 모델의 고유 과제

이산 데이터 처리:

  • 언어는 연속적인 이미지와 달리 이산적 토큰
  • 노이즈 추가/제거 과정의 복잡성
  • 해결: 새로운 노이징/디노이징 알고리즘 개발

추론 단계 최소화:

  • 품질 유지하면서 diffusion step 감소 필요
  • 해결: 적응적 샘플링 알고리즘과 커스텀 스케줄러

시스템 최적화

메모리 효율성:

class MemoryEfficientDiffusion:
    def __init__(self):
        self.gradient_checkpointing = True
        self.mixed_precision = True
        self.dynamic_batching = True
    
    def optimize_memory_usage(self, batch_size, sequence_length):
        # 메모리 사용량 동적 조절
        optimal_config = self.calculate_optimal_config(
            available_memory=torch.cuda.get_device_properties(0).total_memory,
            batch_size=batch_size,
            sequence_length=sequence_length
        )
        return optimal_config

결론

Mercury는 diffusion 기반 언어 모델이라는 새로운 패러다임을 통해 다음과 같은 혁신을 달성했습니다:

핵심 성과

  1. 속도 혁신: 기존 모델 대비 최대 10배 빠른 추론 속도
  2. 품질 유지: 상용 모델과 동등한 코드 생성 품질
  3. 실용성: 실제 개발자들이 사용하는 환경에서 검증된 성능
  4. 확장성: 더 큰 모델로의 스케일링 가능성 입증

산업에 미치는 영향

즉시적 영향:

  • 코드 자동완성 도구의 사용자 경험 혁신
  • 실시간 AI 코딩 어시스턴트 구현 가능
  • 에이전트 기반 개발 워크플로우 활성화

장기적 전망:

  • AI 추론 비용 구조의 근본적 변화
  • 새로운 형태의 인터랙티브 AI 서비스 등장
  • Edge 컴퓨팅 환경에서의 고성능 LLM 활용

Mercury는 단순한 성능 개선을 넘어서 AI 언어 모델의 패러다임 전환을 의미합니다. Diffusion 기반 접근법이 언어 생성 분야에서도 이미지 생성만큼 혁신적인 결과를 가져올 수 있음을 증명한 이 연구는, 앞으로 더 빠르고 효율적인 AI 시스템 개발의 새로운 방향을 제시합니다.

원 논문: Mercury: Ultra-Fast Language Models Based on Diffusion
API 및 플레이그라운드: platform.inceptionlabs.ai | chat.inceptionlabs.ai

참고