---
id: wiki-2026-0508-computational-creativity
title: Computational Creativity
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [computational creativity, AI creativity, generative AI, Margaret Boden, exploration vs exploitation]
duplicate_of: none
source_trust_level: B
confidence_score: 0.85
verification_status: applied
tags: [creativity, generative-ai, computational-creativity, boden, novelty-search, quality-diversity, art]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: psychology / AI
  applicable_to: [Generative AI, Game Design, Music Generation, Co-creation Tools]
---

# Computational Creativity

## 매 한 줄
> **"매 machine 의 inspiration"**. Margaret Boden 의 3 type (combinational + exploratory + transformational). 매 modern: 매 GAN, 매 diffusion, 매 LLM, 매 quality-diversity, 매 evolutionary. 매 imitation 의 X — 매 transformational 의 frontier.

## 매 핵심

### Margaret Boden's 3 type
1. **Combinational**: 매 existing concept 의 새 combination.
2. **Exploratory**: 매 concept space 의 frontier exploration.
3. **Transformational**: 매 space rule 의 break — 매 새 paradigm.

→ 매 LLM / Diffusion 의 most 의 #1 + #2. #3 의 still elusive.

### 매 evaluation criteria
- **Novelty**: 매 다른 가?
- **Quality**: 매 좋 가?
- **Surprise** (Bayesian): 매 expectation 의 violate?
- **Value** (utility): 매 use 가능?

→ 매 4 의 trade-off (novelty vs quality 의 typical).

### 매 method

#### Generative
- **GAN**: 매 photoreal.
- **VAE**: 매 latent control.
- **Diffusion**: 매 modern (Stable, Flux).
- **LLM**: 매 text, code.
- **AutoEncoder**.

#### Search
- **Genetic algorithm**.
- **Simulated annealing**.
- **MCTS**.
- **Bayesian optimization**.

#### Open-ended
- **Novelty Search**: 매 "새로움 만" objective.
- **MAP-Elites**: 매 quality-diversity.
- **POET**: 매 endless challenge.

#### Hybrid
- **Human-AI co-creation**.
- **Critic + generator** (GAN-like).

### 매 응용

#### Art
- **Image**: Stable Diffusion, Midjourney.
- **Music**: Suno, Udio, MusicGen.
- **Video**: Sora, Veo, Runway.
- **3D**: DreamFusion.

#### Game
- **PCG** (Procedural Content Generation).
- **Level design**.
- **NPC behavior**.

#### Science
- **AlphaFold**: 매 protein design.
- **Drug discovery**.
- **Material design** (GNoME).

#### Engineering
- **Topology optimization**.
- **Architecture (building) generation**.

#### Code
- **Copilot, Cursor**: 매 code completion.
- **Aider, Cline**: 매 agentic generation.

### 매 philosophy debate
- "Can machines truly be creative?"
- 매 Strong vs Weak AI 의 connection.
- 매 Searle's Chinese Room.
- 매 attribution / authorship.

→ 매 Boden 의 implementation 가능, 매 transformational 의 hardest.

### 매 modern issue
- **Authorship**: 매 AI 가 / 매 prompt 의 user 가.
- **Training data**: 매 copyright (LAION lawsuit).
- **Evaluation**: 매 subjective.
- **Mode collapse**: 매 generic look.
- **Slop**: 매 quantity > quality.

## 💻 패턴

### Novelty search (vs fitness-based)
```python
import numpy as np

class NoveltySearch:
    def __init__(self, k=15):
        self.archive = []
        self.k = k
    
    def novelty(self, behavior):
        if not self.archive: return 1.0
        distances = [np.linalg.norm(behavior - b) for b in self.archive]
        return np.mean(sorted(distances)[:self.k])
    
    def add(self, behavior):
        if self.novelty(behavior) > 0.5:  # 매 threshold
            self.archive.append(behavior)
    
    def select(self, candidates):
        # 매 select most novel — 매 not most fit
        return max(candidates, key=lambda c: self.novelty(c.behavior))
```

### MAP-Elites (quality-diversity)
```python
from collections import defaultdict

def map_elites(generations=1000, mutate_fn=None, evaluate_fn=None, descriptor_fn=None, grid=10):
    archive = {}  # 매 cell → (fitness, genome)
    
    for gen in range(generations):
        if not archive:
            genome = random_genome()
        else:
            parent = random.choice(list(archive.values()))[1]
            genome = mutate_fn(parent)
        
        fitness = evaluate_fn(genome)
        descriptor = descriptor_fn(genome)
        cell = tuple(int(d * grid) for d in descriptor)
        
        if cell not in archive or archive[cell][0] < fitness:
            archive[cell] = (fitness, genome)
    
    return archive  # 매 grid 의 매 cell 의 best
```

### Co-creation UI (LLM-aided)
```ts
function CoCreationCanvas({ prompt, onUpdate }) {
  return (
    <div>
      <textarea value={prompt} onChange={e => onUpdate(e.target.value)} />
      <div className="suggestions">
        {/* 매 LLM 의 매 alternative direction */}
        {alternatives.map(alt => (
          <button onClick={() => onUpdate(alt)}>
            {alt.description}
          </button>
        ))}
      </div>
      <div className="generated">
        {/* 매 다양한 stage 의 generated content */}
      </div>
    </div>
  );
}
```

### Diffusion + style mixing
```python
def style_combine(prompt_a, prompt_b, mix_ratio=0.5, n_steps=30):
    """매 두 prompt 의 latent 의 mix → 매 combinational creativity."""
    text_emb_a = text_encoder(prompt_a)
    text_emb_b = text_encoder(prompt_b)
    
    mixed = mix_ratio * text_emb_a + (1 - mix_ratio) * text_emb_b
    
    image = diffusion_pipe(prompt_embeds=mixed, num_inference_steps=n_steps).images[0]
    return image
```

### Music generation (MusicGen)
```python
from audiocraft.models import MusicGen

model = MusicGen.get_pretrained('facebook/musicgen-large')
model.set_generation_params(duration=30)

descriptions = ['hip hop with energetic drums', 'ambient piano with rain']
wav = model.generate(descriptions)
```

### PCG (procedural game level)
```python
def generate_level(theme, difficulty, seed=None):
    """매 cellular automata + 매 ML constraint."""
    rng = np.random.default_rng(seed)
    
    # 매 base CA
    grid = rng.choice([0, 1], size=(50, 50), p=[0.55, 0.45])
    for _ in range(5):
        grid = ca_smooth(grid)
    
    # 매 difficulty constraint
    if difficulty == 'hard':
        grid = add_obstacles(grid, density=0.1)
    
    # 매 theme 의 ML refine
    grid = theme_model(grid, theme)
    
    return grid
```

### Critic-guided generation
```python
def critic_guided(generator, critic, prompt, n_iters=5):
    """매 GAN-like — 매 generator + 매 critic 의 loop."""
    candidate = generator.generate(prompt)
    
    for i in range(n_iters):
        critique = critic.evaluate(candidate, criteria=['novelty', 'quality', 'on-prompt'])
        if all(c.score > 0.7 for c in critique): break
        candidate = generator.refine(prompt, candidate, critique)
    
    return candidate
```

### POET (open-ended evolution)
```python
class POET:
    """매 open-ended challenge generation + 매 agent evolution."""
    def __init__(self):
        self.environments = []
        self.agents = []
    
    def step(self):
        # 매 1. 매 mutate environment (challenge)
        new_env = mutate_env(random.choice(self.environments))
        if not too_easy(new_env) and not too_hard(new_env):
            self.environments.append(new_env)
        
        # 매 2. 매 mutate agent
        for env in self.environments:
            for agent in self.agents:
                if not agent.solved(env):
                    agent.train_on(env)
        
        # 매 3. 매 transfer (agent A 의 env B 의 try)
        for agent in self.agents:
            for env in self.environments:
                if agent.solves(env):
                    record_solver(agent, env)
```

### Authorship / attribution
```python
def attribute_authorship(work, generation_log):
    return {
        'human_contribution': {
            'prompts': generation_log.prompts,
            'curation_decisions': generation_log.selections,
            'manual_edits': generation_log.manual_edits,
        },
        'ai_contribution': {
            'model': generation_log.model_version,
            'generation_count': generation_log.total_generations,
            'auto_decisions': generation_log.auto_choices,
        },
        'attribution': 'human-led (prompt + curate + edit)' if 
            len(generation_log.manual_edits) > 5 else 'AI-generated, human-curated',
    }
```

## 🤔 결정 기준
| 목적 | Approach |
|---|---|
| Image | Diffusion (SD, Flux, MJ) |
| Music | MusicGen / Suno |
| Code | LLM (Cursor, Copilot) |
| Game level | PCG + ML |
| Drug | AlphaFold + RFdiffusion |
| Open-ended | POET / MAP-Elites |
| Co-creation | LLM + human |
| Transformational | 매 still hard |

**기본값**: 매 task-specific generative + 매 human curation + 매 attribution.

## 🔗 Graph
- 부모: [[AI]] · [[Creativity]] · [[Generative-AI|Generative-Models]]
- 응용: [[Stable-Diffusion]] · [[AlphaFold]] · [[PCG]]
- Adjacent: [[Authenticity]] · [[Arts]] · [[Artificial-Life]] · [[Beckett]] (creative AI metaphor)

## 🤖 LLM 활용
**언제**: 매 generative system design. 매 co-creation tool. 매 PCG. 매 art / music / writing.
**언제 X**: 매 deterministic task. 매 fact-based.

## ❌ 안티패턴
- **Imitation 만**: 매 transformational 의 X.
- **Mode collapse**: 매 single style.
- **No human curate**: 매 slop.
- **No attribution**: 매 ethics.
- **Single objective (fitness only)**: 매 novelty 의 lose.
- **Copyright 무시**: 매 lawsuit risk.

## 🧪 검증 / 중복
- Verified (Boden "Creative Mind", Stanley novelty search, MAP-Elites, ALife conferences).
- 신뢰도 B.
- Related: [[Arts]] · [[Authenticity]] · [[Artificial-Life]] · [[Stable-Diffusion]] · [[Best-of-N_Sampling]].

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — Boden 3 + 매 novelty search / MAP-Elites / POET / co-creation code |