2nd/10_Wiki/Topics/AI_and_ML/Collective-Intelligence.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-collective-intelligence	Collective Intelligence	10_Wiki/Topics	verified	self	집단 지성 swarm intelligence wisdom of the crowd prediction market DAO multi-agent	none	B	0.85	applied	collective-intelligence swarm multi-agent emergence prediction-market dao wikipedia open-source		2026-05-10	pending	language applicable_to psychology / multi-agent Multi-Agent AI Crowdsourcing DAO Design Prediction Market

Collective Intelligence

매 한 줄

"매 여럿 의 천재 의 outperform". 매 diversity + independence + decentralization + aggregation 의 4 condition (Surowiecki 2004). 매 modern: 매 multi-agent LLM, 매 DAO, 매 prediction market, 매 open-source. 매 group think 의 trap 의 careful.

매 핵심

Surowiecki's 4 conditions (Wisdom of Crowds 2004)

1. Diversity of opinion.
2. Independence (no peer pressure).
3. Decentralization (local knowledge).
4. Aggregation (mechanism to combine).

→ 매 4 의 모두 의 satisfy 시 의 collective > individual.

매 example

• Galton's ox (1906): 매 800 fair-goer 의 median 의 actual.
• Wikipedia: 매 millions of editor → 매 encyclopedic.
• Open source: 매 Linux, 매 React, 매 Linus's Law ("many eyes shallow bug").
• Stack Overflow: 매 answer voting.
• Prediction market: 매 IEM, Manifold, Polymarket.
• Ant colony / bee swarm: 매 biological.

매 fail mode

• Group think (Janis): 매 conformity.
• Information cascade: 매 follow first.
• Echo chamber: 매 filter bubble.
• Tyranny of majority: 매 minority 의 silence.
• Gaming: 매 manipulation.
• Centralization creep: 매 power 의 concentrate.

매 mechanism

Voting

• Plurality: 매 simple.
• Approval: 매 multi-tick.
• Ranked-choice: 매 preference.
• Quadratic: 매 cost-quadratic vote.

Prediction market

• Real-money: 매 incentive 의 align.
• Play-money (Manifold): 매 ethics OK.
• LMSR (Logarithmic Market Scoring): 매 algorithmic market maker.

Aggregation

• Mean / median.
• Bradley-Terry (Elo).
• PageRank-like.
• Bayesian.

Deliberation

• Polis (Taiwan): 매 public input + clustering.
• vTaiwan.
• Liquid democracy.

매 modern AI 의 응용

1. Multi-agent LLM: 매 debate, 매 verifier.
2. Society of Mind (Minsky).
3. Mixture of Experts.
4. Self-play (AlphaZero).
5. Crowd RLHF: 매 large-scale labeler.
6. Constitutional AI 의 jury.

매 응용

Software development

• Code review.
• RFC consensus.
• Open source contribution.
• DORA team metrics.

Governance

• DAO: 매 token vote.
• Cooperatives.
• Liquid democracy.

Forecasting

• Prediction market.
• Superforecaster (Tetlock).

Crowdsourcing

• MTurk: 매 microtask.
• Citizen science (Foldit, Galaxy Zoo).
• Wikipedia.

💻 패턴 (응용 — multi-agent LLM, prediction)

Multi-agent debate (LLM)

def multi_agent_debate(question, n_agents=3, rounds=2):
    agents = [LLM(persona=f'agent_{i}') for i in range(n_agents)]
    
    # 매 round 1: independent
    initial = [a.answer(question) for a in agents]
    
    # 매 rounds: refine with peer answers
    history = initial
    for r in range(rounds):
        new_answers = []
        for i, a in enumerate(agents):
            others = [history[j] for j in range(n_agents) if j != i]
            new = a.refine(question, own=history[i], peers=others)
            new_answers.append(new)
        history = new_answers
    
    # 매 aggregate
    return aggregate(history)  # 매 majority / median / weighted

Self-consistency (single model)

def self_consistency(model, question, n=8):
    answers = [model.generate(question, temperature=0.7) for _ in range(n)]
    final_answers = [extract_final_answer(a) for a in answers]
    return Counter(final_answers).most_common(1)[0][0]

Prediction market (LMSR)

import math

class LMSRMarket:
    """매 Logarithmic Market Scoring Rule."""
    def __init__(self, n_outcomes, b=10):
        self.q = [0.0] * n_outcomes
        self.b = b  # 매 liquidity
    
    def cost(self):
        return self.b * math.log(sum(math.exp(qi / self.b) for qi in self.q))
    
    def price(self, outcome):
        return math.exp(self.q[outcome] / self.b) / sum(math.exp(qi / self.b) for qi in self.q)
    
    def buy(self, outcome, shares):
        prev = self.cost()
        self.q[outcome] += shares
        return self.cost() - prev  # 매 cost to buy

Quadratic voting

def quadratic_vote(voter_credits, choices):
    """매 cost = vote² → 매 strong preference 의 cost ↑."""
    votes = {}
    for choice in choices:
        v = voter_credits[choice].get('vote_count', 0)
        cost = v ** 2
        if cost > voter_credits['budget']:
            raise ValueError('Over budget')
        votes[choice] = v
        voter_credits['budget'] -= cost
    return votes

Bradley-Terry (pairwise → score)

import numpy as np
from sklearn.linear_model import LogisticRegression

def bradley_terry(matches, n_items):
    X = np.zeros((len(matches), n_items))
    y = np.ones(len(matches))
    for i, (winner, loser) in enumerate(matches):
        X[i, winner] = 1
        X[i, loser] = -1
    
    clf = LogisticRegression(fit_intercept=False).fit(X, y)
    scores = clf.coef_[0]
    return scores  # 매 LMSYS Arena 의 base

Polis-style deliberation

def cluster_opinions(statements, votes):
    """매 vote matrix 의 cluster 의 group."""
    from sklearn.decomposition import PCA
    from sklearn.cluster import KMeans
    
    # 매 vote matrix: voter × statement (-1, 0, 1)
    pca = PCA(n_components=2).fit_transform(votes)
    clusters = KMeans(n_clusters=3).fit_predict(pca)
    
    # 매 매 cluster 의 representative statement
    consensus = []
    for c in set(clusters):
        cluster_voters = (clusters == c)
        # 매 매 cluster 가 매 같이 +1 의 statement
        statement_avg = votes[cluster_voters].mean(axis=0)
        top_statements = np.argsort(statement_avg)[-3:]
        consensus.append({'cluster': c, 'agree_on': [statements[s] for s in top_statements]})
    
    # 매 universal: 매 모든 cluster 가 +1
    universal = np.where((votes.mean(axis=0) > 0.5) & (votes.std(axis=0) < 0.3))[0]
    return {
        'clusters': consensus,
        'universal_agreement': [statements[s] for s in universal],
    }

Superforecaster aggregation (Tetlock)

def aggregate_forecasts(forecasts, weights=None):
    """매 weighted geometric mean (Tetlock recommended)."""
    if weights is None:
        weights = [1] * len(forecasts)
    weights = np.array(weights) / sum(weights)
    
    # 매 logit transform → 매 weighted average → 매 inverse
    logits = [np.log(p / (1 - p)) for p in forecasts]
    weighted = sum(w * l for w, l in zip(weights, logits))
    return 1 / (1 + np.exp(-weighted))

🤔 결정 기준

상황	Mechanism
Numeric estimate	Median / mean of independents
Forecasting	Prediction market or weighted forecaster
Multi-criteria	Quadratic voting
Pairwise	Bradley-Terry / Elo
Deliberation	Polis / liquid democracy
LLM accuracy	Self-consistency or multi-agent debate
Code review	Required reviewer + LGTM

기본값: 매 4 condition 의 satisfy + 매 aggregation mechanism 의 explicit.

🔗 Graph

• 부모: Multi-agent-System · Decision Theory
• 변형: Swarm_Intelligence · Prediction-Market
• 응용: DAO
• AI 응용: Self-Consistency · Mixture-of-Experts · Best-of-N_Sampling
• Adjacent: Cognitive Biases · Anarchism · Bounded_Rationality · Beliefs

🤖 LLM 활용

언제: 매 multi-agent design. 매 governance system. 매 forecasting. 매 crowdsource. 매 LLM accuracy boost. 언제 X: 매 expert-only domain. 매 fast individual decision.

❌ 안티패턴

• Group think: 매 conformity.
• Information cascade: 매 first vote 의 anchor.
• No diversity: 매 single perspective.
• Centralized aggregation 의 manipulate: 매 platform 의 power.
• Real-money market 의 ethics: 매 medical / political.
• One-shot vote: 매 deliberation X.

🧪 검증 / 중복

• Verified (Surowiecki "Wisdom of Crowds", Tetlock "Superforecasting", Galton 1906).
• 신뢰도 B.
• Related: Anarchism · Bounded_Rationality · Cognitive Biases · Best-of-N_Sampling · Multi-agent-System.

🕓 Changelog

날짜	변경
2026-05-08	Phase 1
2026-05-10	Manual cleanup — Surowiecki 4 + 매 multi-agent debate / LMSR / quadratic vote / Bradley-Terry / Polis code