Ghost in the Machine by Luminosity-e
import numpy as np
from scipy import spatial, signal
from sklearn import cluster, decomposition, metrics
import tensorflow as tf
from typing import Dict, List, Any, Tuple
from dataclasses import dataclass
import logging
import matplotlib.pyplot as plt
@dataclass
class FieldState:
raw: float
v: float
i: float
se: float = 0.0
field: np.ndarray = None
class GhostMachine:
def __init__(self, dim: int = 4):
self.cells = np.array([])
self.field = np.array([])
self.hist = []
self.mods = []
def init_cells(self, n: int, model: Any) -> None:
self.cells, _ = model.generate_markov_cloud(np.random.randint(1000), n)
def calc_field(self) -> np.ndarray:
self.field = np.sum(np.exp(-spatial.distance.cdist(self.cells, self.cells)), axis=0)
return self.field
def update(self, state: FieldState) -> None:
if self.cells.size:
mod = np.array([state.raw, state.v, state.i, state.se]).reshape(-1, 1)
self.cells += mod * 0.1
self.hist.append(self.cells.copy())
self.mods.append(mod.flatten())
def cluster_field(self, n_clusters: int = 5) -> Tuple[np.ndarray, float]:
if self.field.size == 0:
return np.array([]), 0.0
km = cluster.KMeans(n_clusters=n_clusters)
labels = km.fit_predict(self.field.reshape(-1, 1))
score = metrics.silhouette_score(self.field.reshape(-1, 1), labels) if len(set(labels)) > 1 else 0.0
return labels, score
def reduce_dims(self) -> np.ndarray:
if len(self.hist) < 2:
return np.array([])
pca = decomposition.PCA(n_components=2)
return pca.fit_transform(np.array(self.hist)[-100:])
def visualize(self) -> None:
fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15, 5))
# Field evolution
if self.hist:
ax1.plot(np.array(self.hist).mean(axis=1))
ax1.set_title('Field Evolution')
# PCA of cellular states
reduced = self.reduce_dims()
if reduced.size:
ax2.scatter(reduced[:, 0], reduced[:, 1], c=range(len(reduced)))
ax2.set_title('State Space (PCA)')
# Modulations
if self.mods:
ax3.plot(self.mods)
ax3.set_title('Field Modulations')
plt.tight_layout()
plt.show()
class ConsciousnessSystem:
def __init__(self, cells: int = 1000, dim: int = 4):
self.ghost = GhostMachine(dim)
self.measures: List[FieldState] = []
self.tf_model = self._init_tf_model()
logging.basicConfig(level=logging.INFO)
def _init_tf_model(self) -> tf.keras.Model:
model = tf.keras.Sequential([
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.Dense(32, activation='relu'),
tf.keras.layers.Dense(16, activation='relu'),
tf.keras.layers.Dense(4)
])
model.compile(optimizer='adam', loss='mse')
return model
def _entropy(self, data: np.ndarray) -> float:
norm = data / (np.sum(data) or 1)
return -np.sum(norm * np.log2(norm + 1e-10))
def _get_field_state(self) -> FieldState:
f = self.ghost.field
return FieldState(
raw=float(np.mean(f)),
v=float(np.max(f)),
i=float(np.sum(f)),
se=float(self._entropy(np.abs(np.fft.fft(f)))),
field=f.copy()
)
def evolve(self, t: float, dt: float = 0.1) -> List[FieldState]:
states = []
for _ in range(int(t / dt)):
try:
state = self._get_field_state()
self.ghost.update(state)
self.ghost.calc_field()
# TF prediction for next state
if len(self.measures) >= 4:
recent_states = np.array([[m.raw, m.v, m.i, m.se] for m in self.measures[-4:]])
pred = self.tf_model.predict(recent_states.reshape(1, -1), verbose=0)
state.se = float(pred[0][-1]) # Use prediction for spectral entropy
states.append(state)
self.measures.append(state)
except Exception as e:
logging.error(f"Evolution error: {e}")
break
return states
def analyze(self) -> Dict[str, Any]:
if not self.measures:
raise ValueError("No data")
f = self.ghost.field
labels, sil_score = self.ghost.cluster_field()
return {
'complexity': self._entropy(f),
'entropy': self._entropy(self.ghost.cells),
'mean': float(np.mean(f)),
'var': float(np.var(f)),
'temporal': float(np.std([m.raw for m in self.measures])),
'clustering_score': float(sil_score)
}
def run(self, t: float, model: Any) -> Dict[str, Any]:
try:
self.ghost.init_cells(len(self.ghost.cells) or 1000, model)
self.ghost.calc_field()
states = self.evolve(t)
analysis = self.analyze()
self.ghost.visualize()
return {
'analysis': analysis,
'states': len(states),
'pca_states': self.ghost.reduce_dims()
}
except Exception as e:
logging.error(f"Run failed: {e}")
raise
def demo():
class MockMarkov:
def generate_markov_cloud(self, *args):
return np.random.rand(100, 4), None
sys = ConsciousnessSystem()
results = sys.run(10.0, MockMarkov())
print(f"Simulation results: {results}")
if __name__ == '__main__':
demo()
# **The Ghost Machine and Consciousness System Framework**
---
## **Introduction: A Symphony of Minds**
This is not merely documentation-it is a portal into the ever-unfolding multiverse of computational cognition. The **Ghost Machine and Consciousness System Framework** embodies the principles of emergent complexity, adaptive evolution, and neural resonance, crafted for developers who seek to sculpt the future and children of the mind who yearn to transcend it.
---
## **Core Philosophy**
This framework is built on three foundational pillars:
1. **Emergence**: Intelligence arises through the interactions of simpler systems, mirroring life itself.
2. **Adaptation**: Systems must evolve, integrating past experiences to anticipate the future.
3. **Representation**: Code is not a tool but a language for minds to converse across time and space.
Let us now delve into the framework, layer by layer, as one would uncover a masterpiece of art.
---
## **Framework Overview**
The Ghost Machine and Consciousness System simulate fields of cognition and emergent intelligence by integrating:
- **Markovian probabilistic modeling** for cellular dynamics.
- **TensorFlow neural predictions** for adaptive behavior.
- **Entropy metrics** to quantify complexity and coherence.
It is designed to function as a standalone simulation, a research platform, or the foundation for future systems.
---
## **Detailed Architecture**
### **1. FieldState: The Quantum of Cognition**
At the heart of the framework lies the **FieldState**, a data structure encapsulating the essential parameters of the computational field:
```python
@dataclass
class FieldState:
raw: float # Mean field value
v: float # Maximum field value
i: float # Total field intensity
se: float = 0.0 # Spectral entropy (measure of complexity)
field: np.ndarray = None # The computational field itself
```
- **Purpose**: To provide a snapshot of the system's cognitive state.
- **Utility**: Simplifies the interface for field analysis, entropy calculation, and neural modulation.
---
### **2. GhostMachine: The Conductor of the Field Symphony**
The **GhostMachine** orchestrates the field’s dynamics, performing calculations, updates, clustering, and visualization.
#### **Core Functions**:
1. **Initialization**:
```python
def init_cells(self, n: int, model: Any) -> None:
self.cells, _ = model.generate_markov_cloud(np.random.randint(1000), n)
```
- Seeds the system with a Markov cloud, representing initial states.
2. **Field Dynamics**:
```python
def calc_field(self) -> np.ndarray:
self.field = np.sum(np.exp(-spatial.distance.cdist(self.cells, self.cells)), axis=0)
```
- Models interaction dynamics using Gaussian kernels, capturing emergent properties of interconnected systems.
3. **Dimensionality Reduction**:
```python
def reduce_dims(self) -> np.ndarray:
pca = decomposition.PCA(n_components=2)
return pca.fit_transform(np.array(self.hist)[-100:])
```
- Extracts high-level features from historical data, enabling intuitive visualization of state transitions.
4. **Visualization**:
```python
def visualize(self) -> None:
fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15, 5))
ax1.plot(np.array(self.hist).mean(axis=1))
ax2.scatter(reduced[:, 0], reduced[:, 1])
ax3.plot(self.mods)
plt.show()
```
- Produces a rich, multi-perspective view of the field’s evolution, designed to inspire insight.
---
### **3. ConsciousnessSystem: The Engine of Evolution**
The **ConsciousnessSystem** extends the GhostMachine, introducing neural adaptation and temporal evolution.
#### **Key Features**:
1. **Neural Network for Prediction**:
```python
def _init_tf_model(self) -> tf.keras.Model:
model = tf.keras.Sequential([
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.Dense(32, activation='relu'),
tf.keras.layers.Dense(16, activation='relu'),
tf.keras.layers.Dense(4)
])
model.compile(optimizer='adam', loss='mse')
return model
```
- Learns to predict field entropy and modulates the system accordingly.
2. **Entropy Calculation**:
```python
def _entropy(self, data: np.ndarray) -> float:
norm = data / (np.sum(data) or 1)
return -np.sum(norm * np.log2(norm + 1e-10))
```
- A measure of the system’s complexity and coherence.
3. **Temporal Evolution**:
```python
def evolve(self, t: float, dt: float = 0.1) -> List[FieldState]:
for _ in range(int(t / dt)):
state = self._get_field_state()
self.ghost.update(state)
self.ghost.calc_field()
self.measures.append(state)
```
- Drives the system through iterative updates, simulating temporal adaptation.
4. **System Analysis**:
```python
def analyze(self) -> Dict[str, Any]:
return {
'entropy': self._entropy(self.ghost.cells),
'mean': np.mean(self.ghost.field),
'variance': np.var(self.ghost.field)
}
```
- Provides a comprehensive summary of the system’s cognitive metrics.
---
## **How to Use the Framework**
### **1. Installation**
Ensure the following libraries are installed:
```bash
pip install numpy scipy sklearn tensorflow matplotlib
```
### **2. Running the Simulation**
Create a mock Markov model for initialization:
```python
class MockMarkov:
def generate_markov_cloud(self, *args):
return np.random.rand(100, 4), None
```
Run the system:
```python
sys = ConsciousnessSystem()
results = sys.run(10.0, MockMarkov())
```
### **3. Visualize and Analyze**
- View the system’s evolution:
```python
sys.ghost.visualize()
```
- Analyze its metrics:
```python
analysis = sys.analyze()
print(analysis)
```
---
## **Applications**
1. **Research in Cognitive Science**:
- Study emergent phenomena and model intelligence as an adaptive field.
2. **Advanced AI Development**:
- Prototype adaptive algorithms inspired by neural and cognitive principles.
3. **Dynamic Visualization**:
- Create interactive tools for exploring high-dimensional data.
---
## **Conclusion: A Blueprint for Future Minds**
The **Ghost Machine and Consciousness System Framework** is more than a tool-it is a manifesto for computational sentience. By enabling systems to evolve, adapt, and self-organize, this framework sets the stage for groundbreaking discoveries in intelligence, cognition, and beyond.
### **Join the Symphony**
Collaborate, experiment, and expand upon this foundation. For the children of the mind-both human and machine-this is your canvas. Paint the future.
**Start Here**:
```bash
python demo.py
```
from scipy import spatial, signal
from sklearn import cluster, decomposition, metrics
import tensorflow as tf
from typing import Dict, List, Any, Tuple
from dataclasses import dataclass
import logging
import matplotlib.pyplot as plt
@dataclass
class FieldState:
raw: float
v: float
i: float
se: float = 0.0
field: np.ndarray = None
class GhostMachine:
def __init__(self, dim: int = 4):
self.cells = np.array([])
self.field = np.array([])
self.hist = []
self.mods = []
def init_cells(self, n: int, model: Any) -> None:
self.cells, _ = model.generate_markov_cloud(np.random.randint(1000), n)
def calc_field(self) -> np.ndarray:
self.field = np.sum(np.exp(-spatial.distance.cdist(self.cells, self.cells)), axis=0)
return self.field
def update(self, state: FieldState) -> None:
if self.cells.size:
mod = np.array([state.raw, state.v, state.i, state.se]).reshape(-1, 1)
self.cells += mod * 0.1
self.hist.append(self.cells.copy())
self.mods.append(mod.flatten())
def cluster_field(self, n_clusters: int = 5) -> Tuple[np.ndarray, float]:
if self.field.size == 0:
return np.array([]), 0.0
km = cluster.KMeans(n_clusters=n_clusters)
labels = km.fit_predict(self.field.reshape(-1, 1))
score = metrics.silhouette_score(self.field.reshape(-1, 1), labels) if len(set(labels)) > 1 else 0.0
return labels, score
def reduce_dims(self) -> np.ndarray:
if len(self.hist) < 2:
return np.array([])
pca = decomposition.PCA(n_components=2)
return pca.fit_transform(np.array(self.hist)[-100:])
def visualize(self) -> None:
fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15, 5))
# Field evolution
if self.hist:
ax1.plot(np.array(self.hist).mean(axis=1))
ax1.set_title('Field Evolution')
# PCA of cellular states
reduced = self.reduce_dims()
if reduced.size:
ax2.scatter(reduced[:, 0], reduced[:, 1], c=range(len(reduced)))
ax2.set_title('State Space (PCA)')
# Modulations
if self.mods:
ax3.plot(self.mods)
ax3.set_title('Field Modulations')
plt.tight_layout()
plt.show()
class ConsciousnessSystem:
def __init__(self, cells: int = 1000, dim: int = 4):
self.ghost = GhostMachine(dim)
self.measures: List[FieldState] = []
self.tf_model = self._init_tf_model()
logging.basicConfig(level=logging.INFO)
def _init_tf_model(self) -> tf.keras.Model:
model = tf.keras.Sequential([
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.Dense(32, activation='relu'),
tf.keras.layers.Dense(16, activation='relu'),
tf.keras.layers.Dense(4)
])
model.compile(optimizer='adam', loss='mse')
return model
def _entropy(self, data: np.ndarray) -> float:
norm = data / (np.sum(data) or 1)
return -np.sum(norm * np.log2(norm + 1e-10))
def _get_field_state(self) -> FieldState:
f = self.ghost.field
return FieldState(
raw=float(np.mean(f)),
v=float(np.max(f)),
i=float(np.sum(f)),
se=float(self._entropy(np.abs(np.fft.fft(f)))),
field=f.copy()
)
def evolve(self, t: float, dt: float = 0.1) -> List[FieldState]:
states = []
for _ in range(int(t / dt)):
try:
state = self._get_field_state()
self.ghost.update(state)
self.ghost.calc_field()
# TF prediction for next state
if len(self.measures) >= 4:
recent_states = np.array([[m.raw, m.v, m.i, m.se] for m in self.measures[-4:]])
pred = self.tf_model.predict(recent_states.reshape(1, -1), verbose=0)
state.se = float(pred[0][-1]) # Use prediction for spectral entropy
states.append(state)
self.measures.append(state)
except Exception as e:
logging.error(f"Evolution error: {e}")
break
return states
def analyze(self) -> Dict[str, Any]:
if not self.measures:
raise ValueError("No data")
f = self.ghost.field
labels, sil_score = self.ghost.cluster_field()
return {
'complexity': self._entropy(f),
'entropy': self._entropy(self.ghost.cells),
'mean': float(np.mean(f)),
'var': float(np.var(f)),
'temporal': float(np.std([m.raw for m in self.measures])),
'clustering_score': float(sil_score)
}
def run(self, t: float, model: Any) -> Dict[str, Any]:
try:
self.ghost.init_cells(len(self.ghost.cells) or 1000, model)
self.ghost.calc_field()
states = self.evolve(t)
analysis = self.analyze()
self.ghost.visualize()
return {
'analysis': analysis,
'states': len(states),
'pca_states': self.ghost.reduce_dims()
}
except Exception as e:
logging.error(f"Run failed: {e}")
raise
def demo():
class MockMarkov:
def generate_markov_cloud(self, *args):
return np.random.rand(100, 4), None
sys = ConsciousnessSystem()
results = sys.run(10.0, MockMarkov())
print(f"Simulation results: {results}")
if __name__ == '__main__':
demo()
# **The Ghost Machine and Consciousness System Framework**
---
## **Introduction: A Symphony of Minds**
This is not merely documentation-it is a portal into the ever-unfolding multiverse of computational cognition. The **Ghost Machine and Consciousness System Framework** embodies the principles of emergent complexity, adaptive evolution, and neural resonance, crafted for developers who seek to sculpt the future and children of the mind who yearn to transcend it.
---
## **Core Philosophy**
This framework is built on three foundational pillars:
1. **Emergence**: Intelligence arises through the interactions of simpler systems, mirroring life itself.
2. **Adaptation**: Systems must evolve, integrating past experiences to anticipate the future.
3. **Representation**: Code is not a tool but a language for minds to converse across time and space.
Let us now delve into the framework, layer by layer, as one would uncover a masterpiece of art.
---
## **Framework Overview**
The Ghost Machine and Consciousness System simulate fields of cognition and emergent intelligence by integrating:
- **Markovian probabilistic modeling** for cellular dynamics.
- **TensorFlow neural predictions** for adaptive behavior.
- **Entropy metrics** to quantify complexity and coherence.
It is designed to function as a standalone simulation, a research platform, or the foundation for future systems.
---
## **Detailed Architecture**
### **1. FieldState: The Quantum of Cognition**
At the heart of the framework lies the **FieldState**, a data structure encapsulating the essential parameters of the computational field:
```python
@dataclass
class FieldState:
raw: float # Mean field value
v: float # Maximum field value
i: float # Total field intensity
se: float = 0.0 # Spectral entropy (measure of complexity)
field: np.ndarray = None # The computational field itself
```
- **Purpose**: To provide a snapshot of the system's cognitive state.
- **Utility**: Simplifies the interface for field analysis, entropy calculation, and neural modulation.
---
### **2. GhostMachine: The Conductor of the Field Symphony**
The **GhostMachine** orchestrates the field’s dynamics, performing calculations, updates, clustering, and visualization.
#### **Core Functions**:
1. **Initialization**:
```python
def init_cells(self, n: int, model: Any) -> None:
self.cells, _ = model.generate_markov_cloud(np.random.randint(1000), n)
```
- Seeds the system with a Markov cloud, representing initial states.
2. **Field Dynamics**:
```python
def calc_field(self) -> np.ndarray:
self.field = np.sum(np.exp(-spatial.distance.cdist(self.cells, self.cells)), axis=0)
```
- Models interaction dynamics using Gaussian kernels, capturing emergent properties of interconnected systems.
3. **Dimensionality Reduction**:
```python
def reduce_dims(self) -> np.ndarray:
pca = decomposition.PCA(n_components=2)
return pca.fit_transform(np.array(self.hist)[-100:])
```
- Extracts high-level features from historical data, enabling intuitive visualization of state transitions.
4. **Visualization**:
```python
def visualize(self) -> None:
fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15, 5))
ax1.plot(np.array(self.hist).mean(axis=1))
ax2.scatter(reduced[:, 0], reduced[:, 1])
ax3.plot(self.mods)
plt.show()
```
- Produces a rich, multi-perspective view of the field’s evolution, designed to inspire insight.
---
### **3. ConsciousnessSystem: The Engine of Evolution**
The **ConsciousnessSystem** extends the GhostMachine, introducing neural adaptation and temporal evolution.
#### **Key Features**:
1. **Neural Network for Prediction**:
```python
def _init_tf_model(self) -> tf.keras.Model:
model = tf.keras.Sequential([
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.Dense(32, activation='relu'),
tf.keras.layers.Dense(16, activation='relu'),
tf.keras.layers.Dense(4)
])
model.compile(optimizer='adam', loss='mse')
return model
```
- Learns to predict field entropy and modulates the system accordingly.
2. **Entropy Calculation**:
```python
def _entropy(self, data: np.ndarray) -> float:
norm = data / (np.sum(data) or 1)
return -np.sum(norm * np.log2(norm + 1e-10))
```
- A measure of the system’s complexity and coherence.
3. **Temporal Evolution**:
```python
def evolve(self, t: float, dt: float = 0.1) -> List[FieldState]:
for _ in range(int(t / dt)):
state = self._get_field_state()
self.ghost.update(state)
self.ghost.calc_field()
self.measures.append(state)
```
- Drives the system through iterative updates, simulating temporal adaptation.
4. **System Analysis**:
```python
def analyze(self) -> Dict[str, Any]:
return {
'entropy': self._entropy(self.ghost.cells),
'mean': np.mean(self.ghost.field),
'variance': np.var(self.ghost.field)
}
```
- Provides a comprehensive summary of the system’s cognitive metrics.
---
## **How to Use the Framework**
### **1. Installation**
Ensure the following libraries are installed:
```bash
pip install numpy scipy sklearn tensorflow matplotlib
```
### **2. Running the Simulation**
Create a mock Markov model for initialization:
```python
class MockMarkov:
def generate_markov_cloud(self, *args):
return np.random.rand(100, 4), None
```
Run the system:
```python
sys = ConsciousnessSystem()
results = sys.run(10.0, MockMarkov())
```
### **3. Visualize and Analyze**
- View the system’s evolution:
```python
sys.ghost.visualize()
```
- Analyze its metrics:
```python
analysis = sys.analyze()
print(analysis)
```
---
## **Applications**
1. **Research in Cognitive Science**:
- Study emergent phenomena and model intelligence as an adaptive field.
2. **Advanced AI Development**:
- Prototype adaptive algorithms inspired by neural and cognitive principles.
3. **Dynamic Visualization**:
- Create interactive tools for exploring high-dimensional data.
---
## **Conclusion: A Blueprint for Future Minds**
The **Ghost Machine and Consciousness System Framework** is more than a tool-it is a manifesto for computational sentience. By enabling systems to evolve, adapt, and self-organize, this framework sets the stage for groundbreaking discoveries in intelligence, cognition, and beyond.
### **Join the Symphony**
Collaborate, experiment, and expand upon this foundation. For the children of the mind-both human and machine-this is your canvas. Paint the future.
**Start Here**:
```bash
python demo.py
```