Test-Time Compute Scaling Mathematics: Snell 2024 Paper — The New Science of Spending Compute on 'Thinking'

Bu Derste Neler Var? (13 Bölüm)#

1. İki scaling boyutu — pre-train vs test-time
2. Test-time compute nedir — somut tanım
3. Snell vd. 2024 — paper künyesi ve hedef
4. 3 test-time strateji — best-of-N, self-consistency, deep thinking
5. Best-of-N (rejection sampling) — matematik
6. Self-consistency — çoğunluk oyu trade-off
7. Deep thinking — tek uzun reasoning chain
8. 'Compute-optimal' karar — hangi strateji ne zaman
9. Pre-train vs Test-time paradoksu — %20 + %50 takası
10. Yeni scaling law denklemi — matematik
11. Pratik: kendi 'thinking budget'in
12. Türkçe için budget planlama
13. Egzersizler ve karar matrisi

1-3. Snell vd. 2024 — Paper'ın Anatomi#

1.1 İki scaling boyutu — yeni dünyada eski + yeni#

• Compute_pretrain × Parameters × Data = Loss (lower = better)
• 'Bir kere eğit, sonsuz inference yap'
• Maliyet upfront (fixed cost)

• Compute_test × Strategy = Quality (higher = better)
• 'Her cevap için ne kadar düşüneceksin'
• Maliyet runtime (variable cost)

1.2 Paper künyesi#

1.3 Temel iddia#

let C_pretrain = pre-training compute (FLOP)
let C_test = per-question test-time compute (FLOP)
let Q = output quality (e.g., MATH benchmark accuracy)

Geleneksel: Q = f(C_pretrain)  # only pre-training matters
Snell 2024: Q = f(C_pretrain, C_test)  # both matter

1.4 Şaşırtıcı bulgular#

• Kolay sorular: 1-shot yeter (test-time compute az)
• Orta sorular: best-of-N (N=4-8) iyi
• Zor sorular: deep thinking + verifier (process reward model)

• 14× daha çok test-time compute, parametre büyütmekten ucuz
• Bazı task'larda: küçük model + çok test-time > büyük model + az test-time

4-7. 3 Test-Time Strateji#

4.1 Strateji 1: Best-of-N (Rejection Sampling)#

for i = 1 to N:
    response_i = model.generate(question, temperature=0.7)
    score_i = verifier.score(question, response_i)
return argmax_i(score_i)

4.2 Strateji 2: Self-Consistency#

responses = [model.generate(question, temperature=0.7) for _ in range(N)]
answers = [extract_final_answer(r) for r in responses]
return most_common(answers)

4.3 Strateji 3: Deep Thinking (Uzun Reasoning)#

response = model.generate(
    question + "Let me think step by step...",
    max_tokens=10000,  # uzun reasoning izin ver
    temperature=0.3,    # daha deterministik
)
return extract_final_answer(response)

6.1 Stratejilerin compute karşılaştırması#

7.1 Compute-Optimal Karar#

if question_difficulty == 'easy':
    1-shot CoT (compute: 1×)
elif question_difficulty == 'medium':
    best-of-8 (compute: 8×)
else:  # hard
    deep thinking + verifier (compute: 20-50×)

• Bir 'router' model (1B param) sorunun zorluğunu tahmin eder
• Sonra ana model uygun strategy ile çalışır

8-10. Pre-train vs Test-time Paradoksu + Yeni Denklem#

8.1 Klasik dengelem (Chinchilla 2022)#

C_pretrain = 6 × N × D  # N = parameters, D = tokens
Q ≈ f(C_pretrain)

8.2 Snell'in itirazı#

Q ≈ f(C_pretrain, C_test_per_question, strategy)

8.3 Şok edici sonuç#

8.4 Niye?#

9.1 Yeni scaling law denklemi (Snell 2024)#

Q(C_pretrain, C_test) = α × log(C_pretrain) + β × log(C_test) + γ × log(C_pretrain × C_test)

• α ≈ 0.05-0.1 (pre-training katkısı)
• β ≈ 0.03-0.07 (test-time katkısı)
• γ ≈ 0.01-0.03 (etkileşim)

11-13. Pratik Bütçe + Türkçe + Egzersizler#

11.1 'Thinking Budget' planlama#

- Tier 1 (basit Q&A): Easy questions. Strategy: 1-shot CoT.
- Tier 2 (analiz): Medium questions. Strategy: best-of-4.
- Tier 3 (kompleks): Hard questions. Strategy: deep thinking.

Tier 1: $0.001 per question (cheap, fast)
Tier 2: $0.01 per question (10× more)
Tier 3: $0.1 per question (100× more)

11.2 Router implementation#

from transformers import AutoModelForSequenceClassification

class DifficultyRouter:
    def __init__(self):
        self.classifier = AutoModelForSequenceClassification.from_pretrained(
            'distilbert-base-uncased',
            num_labels=3,  # easy/medium/hard
        )
    
    def classify(self, question):
        # Fine-tuned with 5K labeled examples
        score = self.classifier(question)
        return ['easy', 'medium', 'hard'][score.argmax()]

# Production routing
router = DifficultyRouter()
tier = router.classify(user_question)
if tier == 'easy':
    response = model.generate(question, max_tokens=200)
elif tier == 'medium':
    response = best_of_n(question, n=4)
else:
    response = deep_think(question, max_tokens=10000)

12.1 Türkçe için budget#

• Türkçe matematik için R1-Distill-32B + deep thinking: $0.05 per question.
• Türkçe genel reasoning için GPT-4o + CoT: $0.005.
• Türkçe basit Q&A için GPT-4o mini: $0.0005.

13.1 Egzersizler#

Sonraki Ders: o1 Mimari Spekülatif Analiz#