2nd/10_Wiki/Topic_Programming/AI_and_ML/Antifragility.md

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

id	title	category	status	canonical_id	aliases	duplicate_of	source_trust_level	confidence_score	verification_status	tags	raw_sources	last_reinforced	github_commit	tech_stack
wiki-2026-0508-antifragility	Antifragility	10_Wiki/Topics	verified	self	안티프래질 antifragile Taleb barbell strategy chaos engineering	none	B	0.88	applied	systems-thinking resilience taleb chaos-engineering risk-management distributed-systems		2026-05-10	pending	language applicable_to systems thinking Distributed Systems Risk Management ML Training

Antifragility

📌 한 줄 통찰

"매 chaos 의 먹고 자라는 힘". 매 robust (견딤) 의 위, 매 antifragile (강해짐). Taleb 의 개념. 매 muscle, 매 startup ecosystem, 매 chaos engineering, 매 evolutionary algorithm 의 same.

📖 핵심

매 3 state

State	매 shock 응답	예
Fragile	매 break	유리, 관료제, complex system
Robust	매 unchanged	돌, firewall
Antifragile	매 stronger	근육, immune, startup, evolution

Taleb 의 4 books (Incerto)

1. Fooled by Randomness (2001): 매 luck vs skill.
2. Black Swan (2007): 매 rare + huge impact event.
3. Antifragile (2012): 매 disorder 의 응용.
4. Skin in the Game (2018): 매 risk 의 personal share.

매 적용 원칙

1. Barbell strategy: 매 90% safe + 10% extreme upside. 매 middle 의 회피.
2. Optionality: 매 cheap experiment + downside 작은. 매 upside open.
3. Small stressors: 매 vaccine, 매 chaos monkey.
4. Via negativa: 매 add 보다 매 subtract.
5. Skin in the game: 매 decision-maker 의 risk 의 share.

매 system design 의 응용

1. Chaos engineering: 매 Netflix Chaos Monkey, 매 random kill 의 resilience 강화.
2. Microservices: 매 fault 의 isolation, 매 cascading X.
3. Decentralization: 매 single point of failure 의 회피.
4. Immutable infra: 매 snapshot + recreate.
5. Circuit breaker: 매 cascade 방지.

ML 의 응용

1. Adversarial training: 매 attack 의 train → 매 robust.
2. Data augmentation: 매 noise 의 generalize.
3. Dropout: 매 random kill 의 generalize.
4. Curriculum + difficulty: 매 step-up.
5. Ensemble: 매 multi-model 의 hedge.

Hormesis (생물학 의 antifragility)

• 매 small stress → adaptation.
• 매 운동 (muscle micro-tear).
• 매 fasting (autophagy).
• 매 cold exposure (mitochondria).
• 매 sauna (heat shock protein).

💻 패턴

Chaos Monkey (Netflix)

import random

class ChaosMonkey:
    def __init__(self, kill_probability=0.001):
        self.p = kill_probability
    
    def maybe_kill(self, instance):
        if random.random() < self.p:
            instance.terminate()
            log(f'CHAOS: killed {instance.id}')
    
    def run(self, fleet, interval=60):
        while True:
            for instance in fleet:
                self.maybe_kill(instance)
            sleep(interval)

→ 매 production 의 random failure 의 inject. 매 dependency 의 invisible 의 surface.

Circuit breaker (resilience4j-style)

class CircuitBreaker {
  private failures = 0;
  private state: 'closed' | 'open' | 'half-open' = 'closed';
  
  async call<T>(fn: () => Promise<T>): Promise<T> {
    if (this.state === 'open') throw new CircuitOpen();
    
    try {
      const result = await fn();
      this.failures = 0;
      this.state = 'closed';
      return result;
    } catch (e) {
      this.failures++;
      if (this.failures > 5) this.state = 'open';
      throw e;
    }
  }
}

Barbell portfolio

def barbell_allocate(capital, safe_rate=0.001, risky_p_win=0.01, risky_payoff=100):
    # 매 90% safe (cash, treasuries)
    safe = capital * 0.90
    # 매 10% extreme upside (venture, crypto, lottery-like)
    risky = capital * 0.10
    
    expected = safe * safe_rate + risky * (risky_p_win * risky_payoff - 1)
    return {'safe': safe, 'risky': risky, 'EV': expected}

→ 매 fragile middle (mid-risk bond) 의 회피.

Adversarial training (PyTorch)

def fgsm_attack(model, x, y, epsilon=0.01):
    x.requires_grad = True
    loss = F.cross_entropy(model(x), y)
    loss.backward()
    perturbed = x + epsilon * x.grad.sign()
    return perturbed.detach()

# 매 training loop 에 inject
for x, y in loader:
    x_adv = fgsm_attack(model, x, y)
    loss = F.cross_entropy(model(torch.cat([x, x_adv])), torch.cat([y, y]))

🤔 결정 기준

상황	적용
Distributed system	Chaos engineering + circuit breaker
Investment	Barbell portfolio
ML model	Adversarial + augmentation
Career	Optionality (side project + stable job)
Health	Hormesis (exercise, fasting)
Org	Decentralization, post-mortem culture

기본값: 매 small stressor 의 expose. 매 optionality 의 increase. 매 fragile middle 의 회피.

🔗 Graph

• 부모: Risk_Management · Systems_Thinking · Resilience
• 변형: Robustness
• 응용: Chaos-Engineering · Circuit-Breaker · Barbell-Strategy
• Adjacent: Reinforcement-Learning · Evolutionary-Algorithm

🤖 LLM 활용

언제: 매 system resilience design. 매 risk decision. 매 ML robustness. 매 organizational design. 언제 X: 매 single critical component (매 chaos 의 X). 매 zero-tolerance system (medical, aerospace 의 specific).

❌ 안티패턴

• Optimization 의 fragile: 매 over-optimized = 매 brittle.
• Big bang deploy: 매 small stressor X.
• No skin in the game: 매 decision-maker 의 escape.
• Predict 의 over-reliance: 매 black swan 의 ignore.
• 모든 risk 의 minimize: 매 upside X.
• 매 chaos 의 random: 매 hypothesis 없음.

🧪 검증 / 중복

• Verified (Taleb, Netflix Chaos Engineering paper).
• 신뢰도 B.
• Related: Chaos-Engineering · Black-Swan · Adversarial-Training.

🕓 Changelog

날짜	변경
2026-05-08	Phase 1
2026-05-10	Manual cleanup — Taleb principles + chaos engineering + barbell + ML 응용