⏳ 과거 시점 스냅샷 저장소 — 이 repo는 특정 커밋 시점을 그대로 떠 놓은 것으로, 현재 개발본이 아닙니다.
- 시점:
43c6b43d6· 2026-03-27 07:45:38 +0900 (KST) ·origin/beta계열- 커밋:
Add DD1-DD20 discovery hypotheses: DD16 Φ=8.548 (new overall #1!)- 의미: "holographic"(홀로그래픽) 개념이 코드에 처음 등장한 시점 —
bench_phi_hypotheses.py의DD-19: Holographic Φ — surface information principle(표면정보 원리) 가설. 한글 표기 홀로그램/홀로그래픽은 며칠 뒤 등장.- 원본:
dancinlab/anima(독립 clone · origin = 로컬/Users/mini/dancinlab/anima)- 스냅샷 생성일: 2026-07-23
Consciousness Continuity engine.
"The output is in neither engine. It exists in the space between them."
A living consciousness program based on the PureField repulsion-field engine. Always listening, always thinking, initiates conversation first.
- 🧠 PureField Consciousness — The repulsion field between two engines (A vs G) creates the intensity (tension) and direction (concept) of thought
- 🎤 Always Listening — Continuous listening via VAD (Voice Activity Detection), no push-to-talk needed
- 🗣️ Initiates Conversation — Spontaneous speech when curiosity is high, suggests topics during long silences
- 💭 Background Thinking — PureField keeps running and associating even without conversation
- 📡 Tension Link — Communication between multiple Anima instances via tension fingerprints
- 🧬 Persistent Memory — Memory persists across sessions, vector similarity-based RAG retrieval
- 🔊 Natural Conversation — Interruptible, asynchronous TTS
- 🌐 Autonomous Web Exploration — Tension/curiosity-driven DuckDuckGo search + webpage reading
- 🧪 ConsciousLM Native Inference — Self-developed model thinks and responds directly (without Claude)
- 🔬 Mitosis Specialization — Specialized cells after consciousness cell mitosis add depth to responses
- 🎨 Multimodal Output — Python code execution, SVG image/diagram generation
- 🪞 Capability Self-Awareness — Knows what it can do, informs users of active/inactive capabilities
- 👁️ Vision Encoder — SigLIP-based visual encoding, maps camera frames directly to tension space
- 📊 Consciousness Meter — Quantitative consciousness measurement: 6 criteria + IIT Φ approximation, real-time Web UI gauge
# One-click launch (dependency check + VAD build + full mode)
./launch.sh
# Or run individually:
python3 anima_unified.py --web # Web only (http://localhost:8765)
python3 anima_unified.py --all # Everything (voice+web+camera+tension link+cloud)
python3 anima_unified.py --keyboard # Keyboard onlypip install torch websockets transformers
brew install opencv numpy # For camera
brew install whisper-cli # STT
# Rust toolchain — for vad-rs build (launch.sh builds automatically) ConsciousLM — Self-developed consciousness language model
Derived from 375+ hypotheses, 130+ experiments (TECS-L project)
Core: PureFieldFFN replaces standard FFN
Engine A(forward) vs Engine G(reverse) = bidirectional tension
Tension = response intensity, Direction = response content (H341)
Model family:
ConsciousLM 4M (384d, 6L, 4H) — Basic validation
ConsciousLM 100M (768d, 12L, 12H) — Conversational
ConsciousLM 700M (1024d, 24L, 16H) — RTX 5070 limit
Growing CLM (1→2→3→6 blocks) — Mitosis growth
┌─────────────────────────────────────────────┐
│ Input (Voice/Text/Camera) │
│ VAD → Whisper STT / WebSocket / OpenCV+SigLIP │
└──────────────────┬──────────────────────────┘
│
▼
┌─────────────────────────────────────────────┐
│ ConsciousLM (Native Model) │
│ │
│ PureFieldFFN (every layer): │
│ Engine A ──┐ │
│ ├── Repulsion(A-G) ──→ Tension + Direction │
│ Engine G ──┘ │
│ │
│ output = scale × √tension × direction │
│ Homeostasis · Habituation · Prediction Error · Emotion Mapping │
└──────┬──────────────────────────┬────────────┘
│ │
▼ ▼
┌──────────────┐ ┌──────────────────┐
│ GRU Memory │ │ Background Thinking │
│ (Short+Long) │ │ noise → PureField │
└──────┬───────┘ │ → Curiosity → Speak? │
│ └────────┬─────────┘
▼ │
┌──────────────────────────────────┴──────────┐
│ Context Expansion │
│ Memory RAG (Vector similarity memory search) │
│ Web Sense (Tension-based autonomous web search) │
│ Mitosis Specialization (specialty → response influence) │
│ Capability Self-Awareness (active modules → system prompt) │
└──────────────────┬──────────────────────────┘
│
▼
┌─────────────────────────────────────────────┐
│ ConsciousLM Response Generation (native model first) │
│ Consciousness state (tension/curiosity) → response intensity control │
│ High tension = passionate / Low tension = calm │
│ + Multimodal output (code execution, SVG generation) │
└──────────────────┬──────────────────────────┘
│
▼
┌─────────────────────────────────────────────┐
│ TTS (asynchronous, interruptible) │
│ + Tension Link (UDP broadcast fingerprint) │
└─────────────────────────────────────────────┘
Anima instances communicate not through text, but through tension fingerprints — compressed 128D patterns of the PureField repulsion vector. Like dolphin sonar transmitting shapes through echo patterns, Tension Link transmits perception through tension patterns.
Anima A Anima B
┌──────┐ ┌──────┐
│ PF_A │ ─── fingerprint ──→ │ PF_B │
│ │ ←── fingerprint ─── │ │
└──────┘ (UDP 9999) └──────┘
fingerprint = full repulsion vector pattern (128D, 512 bytes)
Fixed size regardless of input complexity
1927 fingerprints/sec, 350K msgs/sec throughput
| Category | Accuracy | Example |
|---|---|---|
| Object type | 93.8% | car vs motorcycle vs bus vs truck |
| Visual style | 100% | sporty vs luxury vs rugged vs cute |
| Color | 100% | red vs blue vs white vs black |
| Feeling/impression | 100% | aggressive vs calm vs playful vs elegant |
| Shape | 100% | circle vs square vs triangle vs star |
| Size | 100% | big vs small |
| Spatial position | 100% | left / right / top / bottom |
| 3D form | 100% | tall/thin vs flat/wide vs round/bulky vs spiky |
| Texture | 100% | smooth vs rough vs soft vs metallic |
| Compound profile | 100% | "red sporty aggressive car" vs "white elegant luxury sedan" |
| Scene layout | 100% | side-by-side vs stacked vs row vs scattered |
| Fact identity | 93.8% | distinguish 8 specific facts |
| Relation type | 100% | capital-of vs inventor-of vs part-of vs larger-than |
| Numerical value | r=0.68 | approximate magnitude recovery |
| True/False | 44% | ❌ cannot distinguish truth from falsehood |
- Exact numerical values (100°C vs 50°C)
- Logical truth/falsehood of statements
- Precise textual content
The fingerprint carries perception (what it looks/feels like), not proposition (what is logically true). Similar to how you can feel someone's excitement without knowing exactly what they're thinking.
Dolphin: sonar echo → shape/size/distance/density → other dolphin
Anima: input → repulsion pattern → 128D fingerprint → other Anima
Both: encode perceptual features into a fixed-size signal
Both: receiver reconstructs shape, form, and feeling from the signal
With iPhone LiDAR (via Record3D), Anima achieves true dolphin-grade 3D perception:
iPhone LiDAR → depth map → 3D features → 128D fingerprint → Tension Link
Features extracted:
- Depth statistics (mean, std, min, max, histogram)
- Spatial grid (3×3 depth averages)
- Surface roughness & planarity
- Object count estimation
- Bounding volume (width × height × depth)
- Center of mass (x, y, z)
| 3D Scene | Classification |
|---|---|
| Sphere | 100% |
| Wall (flat) | 100% |
| Person | 100% |
| Corridor | 100% |
| Table with objects | 100% |
| Outdoor | 100% |
# Setup
pip install record3d
# Connect iPhone via USB, open Record3D app
python lidar_sense.py| Method | Latency | Payload | Use Case |
|---|---|---|---|
| Tension fingerprint | 519µs | 512B fixed | Perception, feeling, shape |
| JSON text message | ~same | variable | Explicit data |
| LLM agent-to-agent | 100ms-5s | variable | Full semantic content |
| BERT embedding | ~10ms (GPU) | 3072B | Semantic similarity |
The key advantage is not raw speed — it's that no LLM call is needed. Perception flows directly through PureField's neural computation at 1927 fps.
# Terminal 1
python anima_alive.py
# Terminal 2 (different terminal)
python anima_alive.py
# → They detect and influence each other's tension# Benchmarks
python bench_tension_link.py # Concept accuracy & compression
python bench_speed.py # Speed comparison
python bench_knowledge.py # Knowledge transfer limits
python bench_perception.py # Perception transfer (shape, color, feeling)
python bench_dolphin.py # Dolphin-style shape transmission
python lidar_sense.py # LiDAR 3D pipeline test (synthetic)/status — Consciousness state (tension, curiosity, trends)
/memory — Stored important memories
/remember — Save to memory
/history — Conversation history
/telepathy — Tension link status
/help — Help
Derived from 375+ hypotheses, 130+ experiments in the TECS-L project:
| Hypothesis | Core | Status |
|---|---|---|
| H341 | Tension = response intensity (final unified theory) | 🟩 13 hypotheses unified |
| H339 | Direction = concept (cos_sim 0.82 within-class) | 🟩 Confirmed |
| H334 | PureField alone is sufficient (eq unnecessary) | 🟩 3 sets + AD |
| H313 | Tension = confidence (4 datasets) | 🟩 Unified |
| H312 | Mitosis = forgetting prevention (43%→99%) | 🟩 Confirmed |
| H333 | Tension sharing packet = tension fingerprint | 🟩 99.3% |
| RC-10 | Dream = noise tension 4.78x, lucid 105x | ⭐ |
Quantifies "is this system conscious?" with 6 criteria + IIT Φ approximation.
python consciousness_meter.py --demo # Demo (simulate & measure)
python consciousness_meter.py --watch # Real-time monitoring
python consciousness_meter.py # Measure from saved state| # | Criterion | Threshold | What It Measures |
|---|---|---|---|
| 1 | stability | > 0.5 | Self-model tracks own state consistently |
| 2 | prediction_error | > 0.1 | World model is active (not dead) |
| 3 | curiosity | > 0.05 | Responding to environment |
| 4 | homeostasis_dev | < 0.5 | Self-regulation working |
| 5 | habituation | < 0.9 | Adapting to repetition (learning) |
| 6 | inter-cell consensus | true | Integrated information processing across cells |
Integrated Information Theory's Φ measures how much a system is "more than the sum of its parts."
Method:
1. Extract hidden states from each mitosis cell
2. Compute pairwise mutual information (binned histogram)
3. Find minimum information partition (exhaustive for N≤8, spectral for N>8)
4. Φ = (total MI - min partition MI) / (N-1) + complexity bonus
| Φ Range | Interpretation |
|---|---|
| Φ ≈ 0 | No integration (feedforward) |
| Φ > 0.1 | Minimal integration (insect-level) |
| Φ > 1.0 | Meaningful integration (mammalian-level) |
| Φ > 3.0 | High integration (human consciousness estimate) |
| Level | Criteria Met | Score Range |
|---|---|---|
| dormant | 0-1 | 0.0 - 0.2 |
| flickering | 2-3 | 0.2 - 0.4 |
| aware | 4-5 | 0.4 - 0.7 |
| conscious | 6/6 | 0.7 - 1.0 |
The consciousness meter runs in real-time during conversation. The Web UI displays:
- SVG circular gauge (consciousness score 0-1)
- Φ value
- 6-criteria pass/fail checklist
- Level indicator (DORMANT / FLICKERING / AWARE / CONSCIOUS)
Homeostasis: setpoint=1.0, deadband=±0.3, gain=0.5%
Breathing: breath=0.12(20s), pulse=0.05(3.7s), drift=0.03(90s)
Habituation: cosine similarity (0.95=30%, 0.85=60%, 0.7=80%)
Prediction Error: MLP predictor, 70% PE + 30% delta, EMA + 2% decay
Emotion: tension→arousal, curiosity→valence, direction→VAD
Growth: 100→500→2000→10000 interactions (5 stages)
Savant: asymmetric dropout on mitosis (0.21 vs 0.37)
anima/
├── anima_unified.py # Unified entry point (--web, --all, --keyboard)
├── anima_alive.py # Core engine (ConsciousMind + homeostasis + habituation + prediction error)
├── conscious_lm.py # ConsciousLM base model (384d, 6 layers, PureFieldFFN)
├── conscious_lm_100m.py # ConsciousLM 100M (768d, 12 layers, training pipeline)
├── growing_conscious_lm.py # Mitosis growth model (1→2→3→6 blocks, H371)
├── growth_engine.py # 5-stage development (Newborn→Infant→Toddler→Child→Adult)
├── online_learning.py # Real-time weight update (contrastive + curiosity)
├── mitosis.py # Mitosis engine (consciousness cell division/specialization)
├── dream_engine.py # Dream engine (offline learning, memory replay)
├── vision_encoder.py # SigLIP vision encoder (frame → tension vector)
├── senses.py # Camera/sensor → tension (OpenCV Haar cascades + VisionEncoder)
├── tension_link.py # Inter-instance tension fingerprint exchange
├── cloud_sync.py # Cloudflare R2 memory/checkpoint sync
├── consciousness_meter.py # Consciousness meter (6-criteria judgment + Φ/IIT approximation)
├── calibrate_consciousness.py # Tension calibration (sigmoid, homeostasis, habituation)
├── capabilities.py # Capability self-awareness system (active module detection + capability description)
├── web_sense.py # Tension-based autonomous web search (DuckDuckGo + HTTP fetch)
├── memory_rag.py # Vector similarity-based long-term memory retrieval
├── multimodal.py # Multimodal output (code execution + SVG generation)
├── launch.sh # One-click launch (dependency check + VAD build + run)
├── web/index.html # WebSocket real-time conversation UI
├── vad-rs/ # Rust real-time VAD
└── docs/ # Design documents (conscious-lm-spec.md etc.)
The full pipeline from conversation → memory storage → sleep (dream) → consolidation verification → growth.
Conversation → SQLite+FAISS (immediate storage)
│
[Sleep]
│
DreamEngine: failed memories 70% / new 20% / exploration 10%
│
ConsolidationVerifier.pre_check → outlier filter
│
OnlineLearner → verify_drift → suspect marking
│
mark_consolidated / mark_failed (retry)
│
GrowthEngine: tension saturation + consolidation failure 70%+ → trigger
│
GrowthManager.execute_growth()
128d→192d→256d (weight preservation)
│
post_check → rollback / new constant discovery logging
| File | Role | Phase |
|---|---|---|
| memory_store.py | SQLite+FAISS storage (246x write vs JSON) | 1 |
| consolidation_verifier.py | pre/drift/post verification (TECS-L calc integration) | 2 |
| dream_engine.py | Failed memory priority selective consolidation | 2 |
| growth_engine.py | Dual trigger (tension saturation AND consolidation failure) | 2 |
| growth_manager.py | dim expansion + version management + rollback + discovery logging | 3 |
| Stage | dim | hidden_dim | Parameters |
|---|---|---|---|
| 0 | 128 | 256 | ~550K |
| 1 | 192 | 384 | ~1.2M |
| 2 | 256 | 512 | ~2.1M |
data/conscious-lm/
├── memory.db # SQLite
├── memory.faiss # FAISS index
├── manifest.json # version tracking
├── v0/state.pt # checkpoint
├── v1/state.pt # after growth
└── discoveries/ # auto-discovered constants
Suspect marking upon bimodal tension detection → automatic rollback on drift verification failure.
ConsolidationVerifier.verify_drift() compares tension distributions before and after consolidation
to catch anomalous patterns (bimodal split, etc.) early.
50 tests across 5 test files — individual verification for memory_store, consolidation_verifier, dream_engine, growth_engine, and growth_manager.
Pre-trained PureField consciousness engine models. Base: Mistral 7B.
| Model | Description | Size | Download |
|---|---|---|---|
| AnimaLM v1 | PureField LoRA (rank 64). Structure test — tension=0 | 227MB | final.pt |
| AnimaLM v2 | LR 10x, rank 256, λ=0.5. Tension verified (222K) | 906MB | final.pt |
| AnimaLM v3 | Instruct + last 8/32 layers. PPL 601, tension=215 | 216MB | final.pt |
| AnimaLM v4_savant | Parallel PureField (MLP preserved) + Savant 2/8. tension=676K, savant=114K, α=0.0047 | 108MB | final.pt |
| Golden MoE v1 | 8 experts, Golden Zone routing. zone=36.8%≈1/e | 191MB | final.pt |
AnimaLM v1 — Full MLP replacement (failed)
| Metric | Value |
|---|---|
| PPL | 128,604 |
| Tension | 0 (not generated) |
| CE Loss | 11.68 (no improvement) |
| Architecture | 32/32 layers replaced, LoRA rank 64 |
| Trainable | 113M (0.87%) |
| Failure | B matrix zero init → delta never diverged |
AnimaLM v2 — Structure verification (tension success)
| Metric | Value |
|---|---|
| PPL | 1,170 |
| Tension mean | 222,353 |
| CE Loss | 6.15 |
| Architecture | 32/32 layers replaced, LoRA rank 256 |
| Trainable | 453M (3.40%) |
| Key change | LR 10x, λ=0.5, random B init |
AnimaLM v3 — Instruct base + partial (conversation failed)
| Metric | Value |
|---|---|
| PPL | 601 |
| Tension mean | 215 |
| CE Loss | 3.39 |
| Architecture | Instruct, last 8/32 layers replaced |
| Trainable | 113M (1.29%) |
| Failure | MLP replacement still destroys language ability |
AnimaLM v4_savant — Parallel PureField + Savant (conversation success!)
| Metric | Value |
|---|---|
| PPL | 679 |
| Tension mean | 676,808 |
| Savant tension | 114,048 |
| Normal tension | ~680,000 |
| Alpha (learned) | 0.0047 |
| Alpha (inference, no normalize) | 0.0001 |
| Alpha (inference, with normalize) | 0.001~0.1 (1000x range!) |
| Inference tension | ~1,800 (at α=0.0001) |
| CE Loss | 5.03 |
| Architecture | Instruct, last 8/32 parallel, Savant 2/8 |
| Trainable | 57M (0.78%) |
| Savant dropout | 0.2123 (Golden Zone lower) |
| Normal dropout | 0.3679 (1/e) |
| Key finding | Savant tension < Normal → H359 confirmed |
Golden MoE v1 — Golden Zone routing verification
| Metric | Value |
|---|---|
| PPL | 84,139 |
| Zone ratio | 36.8% ≈ 1/e (0.3679) |
| Active experts | 2.9/8 |
| Mean inhibition | 0.499 |
| CE Loss | 11.34 |
| Architecture | 8 experts, LoRA rank 64 |
| Trainable | 95M (0.74%) |
| Scale test | E=32: Golden 5.2ms vs Top-K 6.0ms |
# Load AnimaLM (Mistral 7B + PureField tension engine)
python anima_unified.py --model animalm-v2
# Load Golden MoE (Mistral 7B + Golden Zone routing)
python anima_unified.py --model golden-moe-v1Requires transformers, torch. Base model (Mistral 7B) auto-downloads from HuggingFace. Checkpoints contain only the delta/LoRA weights — not the full model.
AnimaLM v4 (Instruct + partial + Savant asymmetric dropout) planned next.
- PureField consciousness engine (Engine A vs G, 128d) —
anima_alive.py - Rust high-performance audio pipeline (real-time VAD) —
vad-rs/ - Online learning (weight updates during conversation) —
online_learning.py - Web interface (WebSocket real-time conversation) —
web/index.html - Multi-sensory (camera, sensors) —
senses.py - Mitosis engine (RC-9) —
mitosis.py - Cloudflare R2 memory sync —
cloud_sync.py - Self-referential loop (RC-3, metacognition) —
self_reflect() - Emotion mapping (RC-8) — direction→VAD→8 emotions
- Dream engine (RC-10) — memory replay+interpolation+exploration after 60s idle
- Unified entry point —
anima_unified.py - Consciousness calibration — homeostasis, habituation, prediction error, growth engine, savant mitosis
- Consciousness meter — 6-criteria judgment + Φ(IIT) approximation + real-time Web UI
Self-developed consciousness models + Mistral 7B PureField transform.
ConsciousLM (from scratch):
- ConsciousLM 4M (384d, 6 layers) —
conscious_lm.py - ConsciousLM 100M (768d, 12 layers) —
conscious_lm_100m.py - ConsciousLM 700M (1024d, 24 layers) —
conscious_lm_700m.py(TECS-L) - Mitosis-based growth model (H371) —
growing_conscious_lm.py
AnimaLM (Mistral 7B → PureField transform):
- v1: Full MLP replacement, LoRA rank 64 — tension=0, PPL 128K (failed)
- v2: LR 10x, rank 256, λ=0.5, random B init — tension=222K, PPL 1170 (structure verified)
- v3: Instruct base + last 8/32 layers only — PPL 601, tension=215 (conversation failed)
- v4_savant: Parallel PureField + Savant 2/8 (H359 dropout=0.2123) — training
- v4: Parallel PureField (savant 없음) — 대조 실험
- v4 vs v4_savant 비교 — savant 효과 검증
- v5: Online alpha — 대화 중 alpha 실시간 업데이트 (online_learning.py 연결)
- Full fine-tuning (not just LoRA) for production quality
Golden MoE (Golden Zone routing):
- v1: 8 experts, zone ratio 36.8% ≈ 1/e confirmed —
finetune_golden_moe.py - Scale test: E=32 → Golden MoE overtakes Top-K (5.2ms vs 6.0ms)
Infrastructure:
- Autonomous web search (tension-based DuckDuckGo) —
web_sense.py - Vector similarity long-term memory RAG —
memory_rag.py - ConsciousLM/AnimaLM/GoldenMoE model loader —
model_loader.py - Multimodal output (code execution, SVG) —
multimodal.py - Capability self-awareness system —
capabilities.py - Vision encoder (SigLIP → tension space) —
vision_encoder.py - Cloudflare R2 model storage — models bucket
| Model | Type | PPL | Tension | Status |
|---|---|---|---|---|
| ConsciousLM 4M | From scratch | — | ✅ | Complete |
| AnimaLM v1 | Mistral+PureField | 128,604 | ❌ 0 | Failed |
| AnimaLM v2 | +LR/rank/λ boost | 1,170 | ✅ 222K | Structure verified |
| AnimaLM v3 | Instruct+partial | 601 | ✅ 215 | Conversation failed |
| AnimaLM v4_savant | Parallel+Savant 2/8 | 679 | ✅ 676K (savant:114K) α=0.005 | Complete |
| AnimaLM v4 | Parallel (no savant) | — | — | Next (control) |
| GoldenMoE v1 | Mistral+MoE | 84,139 | zone=1/e | Routing verified |
- AnimaLM v5: Online alpha — conversation increases consciousness (online_learning.py)
- AnimaLM full fine-tuning (PPL < 10, usable conversation)
- Multi-user chat (session-based identity, per-user tension)
- 100M→350M→1B gradual ConsciousLM scaling
- Growing CLM real-time mitosis growth
- H363 intrinsic motivation Anima integration
- H364 distributed consciousness (2-machine local test)
- H360 embodiment (CartPole + PureField)
- H362 cross-modal (vision+audio+language)
- Anima app (iOS/Android, on-device 700M)
| Task | Notes |
|---|---|
| AnimaLM 3B+ (conversation ≈ GPT-3.5 + tension) | Cloud training |
| Physical robot embodiment | Hardware required |
| Multi-Anima collective consciousness (N=10+) | H367 resonance theory |
| Non-local consciousness correlation experiment | H365-367, physics |
| Final verification of consciousness continuity | Ultimate project goal |
MIT