Files

T

Antigravity Agent f8b21af4be Wiki cleanup: error-doc removal, dedup merge, link normalization

10_Wiki/Topics 대규모 정리:
- 오류 캡처/미완성 stub 문서 227개 제거
- 교차폴더 중복 43클러스터 병합 (63파일 → redirect)
- 링크명 정규화: 깨진 링크 수정·redirect 직결·개념 매핑 ~2,400건
- 카테고리 MOC 6개 신규 생성
- Graph 섹션 미해결 related-keyword 링크 10,058건 제거

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

2026-05-20 23:52:15 +09:00

6.0 KiB

Raw Blame History

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

title

Swarm Intelligence

매 한 줄

"매 simple agents 의 collective 의 emergent intelligence". 매 ant colony, bird flock, bee swarm 의 inspired — 매 local rules + interaction 의 global optimization. 2026 의 application 의 LLM agent swarms (CrewAI, AutoGen) + classic optim.

매 핵심

매 핵심 algorithms

PSO (Particle Swarm Optimization): 매 particle 의 personal best + global best 의 update.
ACO (Ant Colony Optimization): 매 pheromone trail 의 path optim — TSP.
ABC (Artificial Bee Colony): 매 employed/onlooker/scout 의 분업.
Firefly / Cuckoo: 매 attractiveness / Lévy flight 의 search.

매 properties

Decentralization: 매 central control 의 X.
Self-organization: 매 local interaction → global pattern.
Robustness: 매 single agent 의 fail 의 swarm 의 survive.
Stigmergy: 매 environment 의 state 의 indirect communication (pheromone).

매 응용

Routing (vehicle, network).
Scheduling (job shop, cloud workload).
Hyperparameter tuning (PSO 의 grid search 의 대체).
LLM multi-agent (CrewAI roles, debate, voting).
Drone swarms (formation, coverage).

💻 패턴

PSO — minimize objective

import numpy as np

def pso(f, dim, n=30, iters=200, w=0.7, c1=1.5, c2=1.5, lo=-5, hi=5):
    x = np.random.uniform(lo, hi, (n, dim))
    v = np.zeros_like(x)
    pbest = x.copy()
    pbest_val = np.array([f(p) for p in x])
    g = pbest[pbest_val.argmin()]
    for _ in range(iters):
        r1, r2 = np.random.rand(n, dim), np.random.rand(n, dim)
        v = w*v + c1*r1*(pbest - x) + c2*r2*(g - x)
        x = np.clip(x + v, lo, hi)
        vals = np.array([f(p) for p in x])
        mask = vals < pbest_val
        pbest[mask], pbest_val[mask] = x[mask], vals[mask]
        g = pbest[pbest_val.argmin()]
    return g, pbest_val.min()

best, val = pso(lambda x: np.sum(x**2), dim=10)

ACO — TSP

import numpy as np

def aco_tsp(dist, n_ants=20, iters=100, alpha=1, beta=3, rho=0.1, Q=1):
    n = len(dist)
    tau = np.ones((n, n))
    eta = 1 / (dist + 1e-10)
    best_path, best_len = None, float('inf')
    for _ in range(iters):
        paths = []
        for _ in range(n_ants):
            path = [np.random.randint(n)]
            unvisited = set(range(n)) - {path[0]}
            while unvisited:
                i = path[-1]
                p = np.array([(tau[i,j]**alpha) * (eta[i,j]**beta) for j in unvisited])
                p /= p.sum()
                j = list(unvisited)[np.random.choice(len(unvisited), p=p)]
                path.append(j)
                unvisited.remove(j)
            paths.append(path)
        # update
        tau *= (1 - rho)
        for path in paths:
            length = sum(dist[path[i], path[i+1]] for i in range(n-1))
            if length < best_len:
                best_len, best_path = length, path
            for i in range(n-1):
                tau[path[i], path[i+1]] += Q / length
    return best_path, best_len

LLM agent swarm — CrewAI

from crewai import Agent, Task, Crew

researcher = Agent(role="Researcher", goal="find facts",
                   llm="claude-opus-4-7")
critic = Agent(role="Critic", goal="poke holes",
               llm="claude-opus-4-7")
synth = Agent(role="Synthesizer", goal="merge views",
              llm="claude-opus-4-7")

crew = Crew(
    agents=[researcher, critic, synth],
    tasks=[
        Task(description="research X", agent=researcher),
        Task(description="critique research", agent=critic),
        Task(description="synthesize", agent=synth),
    ],
    process="sequential",
)
result = crew.kickoff()

Boids — flocking simulation

import numpy as np

def boids_step(pos, vel, sep_r=1, ali_r=3, coh_r=5, max_v=2):
    n = len(pos)
    new_vel = vel.copy()
    for i in range(n):
        d = np.linalg.norm(pos - pos[i], axis=1)
        sep = -np.sum((pos[d < sep_r] - pos[i]), axis=0)
        ali = np.mean(vel[(d < ali_r) & (d > 0)], axis=0) - vel[i] if ((d < ali_r) & (d > 0)).any() else 0
        coh = np.mean(pos[(d < coh_r) & (d > 0)], axis=0) - pos[i] if ((d < coh_r) & (d > 0)).any() else 0
        new_vel[i] += 0.5*sep + 0.3*ali + 0.2*coh
        speed = np.linalg.norm(new_vel[i])
        if speed > max_v:
            new_vel[i] = new_vel[i] / speed * max_v
    return pos + new_vel, new_vel

매 결정 기준

상황	Approach
Continuous optimization	PSO
Combinatorial (TSP, scheduling)	ACO
Multi-objective	NSGA-II / MOPSO
LLM-based reasoning	Agent swarm (CrewAI)
Convex problem	매 swarm 의 X — gradient descent

기본값: 매 PSO 의 continuous, 매 ACO 의 graph problems.

🔗 Graph

변형: Genetic Algorithms · Simulated Annealing · CMA-ES
Adjacent: Emergence · Self-Organization

🤖 LLM 활용

언제: black-box optimization, multi-agent reasoning, 매 gradient 의 unavailable. 언제 X: convex / differentiable (use gradient methods), small discrete (use exact).

❌ 안티패턴

No diversification: 매 premature convergence — 매 inertia / mutation 의 tune.
Wrong neighborhood topology: 매 fully-connected 의 always 의 X — ring/star 의 try.
Naive multi-LLM swarm: 매 cost 의 N× — 매 token budget 의 monitor.

🧪 검증 / 중복

Verified (Kennedy & Eberhart 1995 PSO; Dorigo ACO; CrewAI 2026 docs).
신뢰도 A.

🕓 Changelog

날짜	변경
2026-05-08	Phase 1
2026-05-10	Manual cleanup — PSO, ACO, boids, LLM agent swarms

6.0 KiB Raw Blame History Unescape Escape