Upload 3 files

app.py

@@ -0,0 +1,537 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+import streamlit as st
+import matplotlib.pyplot as plt
+from collections import defaultdict
+import powerlaw
+from scipy import ndimage
+from scipy.ndimage import gaussian_filter
+import time
+from PIL import Image
+
+# ============================
+# Dendritic Layer Definition
+# ============================
+
+class DendriticLayer:
+    def __init__(self, n_dendrites, size, device='cpu'):
+        self.n_dendrites = n_dendrites
+        self.size = size
+        self.device = device
+
+        # Initialize dendrites as PyTorch tensors on the specified device
+        self.positions = torch.rand(n_dendrites, 2, device=device) * torch.tensor(size, device=device).float()
+        self.directions = torch.randn(n_dendrites, 2, device=device)
+        norms = torch.norm(self.directions, dim=1, keepdim=True)
+        self.directions = self.directions / (norms + 1e-8)
+        self.strengths = torch.ones(n_dendrites, device=device)
+        self.points = torch.zeros((n_dendrites, 2), device=device)
+
+        # Field state as a PyTorch tensor on the device
+        self.field = torch.zeros(size, device=device)
+
+    def process(self, input_field):
+        """Process input through dendritic growth"""
+        # Normalize input
+        input_norm = self._normalize(input_field)
+
+        # Reset field
+        self.field.zero_()
+
+        # Compute indices for all dendrites
+        indices = self.positions.long() % torch.tensor(self.size, device=self.device).unsqueeze(0)
+        x = indices[:, 0]
+        y = indices[:, 1]
+
+        # Gather field values at dendrite positions
+        field_vals = input_norm[x, y]
+
+        active = field_vals > 0.1
+        active_indices = active.nonzero(as_tuple=False).squeeze()
+
+        if active_indices.numel() > 0:
+            # Compute gradients
+            try:
+                grad_y, grad_x = torch.gradient(input_norm)
+            except Exception as e:
+                # Handle scenarios where torch.gradient might fail
+                grad_x = torch.zeros_like(input_norm)
+                grad_y = torch.zeros_like(input_norm)
+                print(f"Gradient computation error: {e}")
+
+            grad_val_x = grad_x[x[active], y[active]]
+            grad_val_y = grad_y[x[active], y[active]]
+            grad_norm = torch.sqrt(grad_val_x**2 + grad_val_y**2) + 1e-8
+
+            # Update directions for active dendrites
+            direction_updates = torch.stack([grad_val_x, grad_val_y], dim=1) / grad_norm.unsqueeze(1)
+            self.directions[active] = 0.9 * self.directions[active] + 0.1 * direction_updates
+            self.directions[active] /= torch.norm(self.directions[active], dim=1, keepdim=True) + 1e-8
+
+            # Grow dendrites
+            self.points[active] = self.positions[active] + self.directions[active] * self.strengths[active].unsqueeze(1)
+            self.strengths[active] *= (1.0 + field_vals[active] * 0.1)
+
+            # Update field
+            self.field[x[active], y[active]] += field_vals[active] * self.strengths[active]
+
+        # Smooth field using Gaussian filter (move to CPU for scipy)
+        field_cpu = self.field.cpu().numpy()
+        field_smoothed = gaussian_filter(field_cpu, sigma=1.0)
+        self.field = torch.from_numpy(field_smoothed).to(self.device)
+
+        return self._normalize(self.field)
+
+    def _normalize(self, tensor):
+        """Safely normalize tensor to [0,1] range"""
+        min_val = tensor.min()
+        max_val = tensor.max()
+        return (tensor - min_val) / (max_val - min_val + 1e-8) if max_val > min_val else tensor
+
+# =====================================
+# Critical Dendritic Field Definition
+# =====================================
+
+class CriticalDendriticField(nn.Module):
+    def __init__(self, field_size=64, n_dendrites=1000, device='cpu'):
+        super().__init__()
+        self.field_size = field_size
+        self.device = device
+
+        # Critical parameters
+        self.coupling_strength = 0.015
+        self.min_coupling = 0.01
+        self.max_coupling = 0.02
+        self.adjustment_rate = 0.0001
+        self.optimal_variance = 0.4
+        self.variance_tolerance = 0.1
+
+        # Initialize field components
+        self.field = torch.zeros((field_size, field_size), 
+                                 dtype=torch.complex64, device=device)
+        self.field_shape = self._setup_field_shape()
+
+        # Dendritic layer
+        self.dendrites = DendriticLayer(
+            n_dendrites=n_dendrites,
+            size=(field_size, field_size),
+            device=device
+        )
+
+        # Pattern storage
+        self.word_patterns = {}
+        self.pattern_strengths = defaultdict(float)
+        self.pattern_history = defaultdict(list)
+
+        # Critical state tracking
+        self.stability_window = []
+        self.avalanche_sizes = []
+
+        # Initialize with scale-free noise
+        self._initialize_scale_free()
+
+        # Additional attributes for GUI controls
+        self.pattern_threshold = 0.5  # Default threshold
+
+    def _setup_field_shape(self):
+        """Create brain-like field shape"""
+        shape = torch.ones(self.field_size, self.field_size, device=self.device)
+
+        # Create cortical-like layers
+        layers = torch.linspace(0.5, 1.0, 6, device=self.device)
+        for i, strength in enumerate(layers):
+            start = i * (self.field_size // 6)
+            end = (i + 1) * (self.field_size // 6)
+            shape[start:end, :] *= strength
+
+        # Add some columnar structure
+        columns = torch.cos(torch.linspace(0, 4 * np.pi, self.field_size, device=self.device))
+        shape *= (0.8 + 0.2 * columns.unsqueeze(0))
+
+        return shape
+
+    def _initialize_scale_free(self):
+        """Initialize with 1/f pink noise"""
+        kx = torch.fft.fftfreq(self.field_size, d=1.0).to(self.device)
+        ky = torch.fft.fftfreq(self.field_size, d=1.0).to(self.device)
+        kx, ky = torch.meshgrid(kx, ky, indexing='ij')
+        k = torch.sqrt(kx**2 + ky**2)
+        k[0, 0] = 1.0  # Avoid division by zero
+
+        noise = torch.randn(self.field_size, self.field_size, dtype=torch.complex64, device=self.device)
+        noise_fft = torch.fft.fft2(noise)
+        self.field = torch.fft.ifft2(noise_fft / (k + 1e-8)**0.75)
+
+    def _evolve_pattern(self, pattern):
+        """Evolve pattern through critical dynamics"""
+        # Phase coupling
+        phase = torch.angle(pattern)
+        phase_diff = torch.roll(phase, shifts=1, dims=-1) - phase
+        coupling = torch.exp(1j * phase_diff) * self.coupling_strength
+
+        # Add turbulence
+        energy = torch.mean(torch.abs(pattern))
+        noise_scale = 0.001 * (1.0 - torch.sigmoid(energy))
+        noise_real = torch.randn_like(pattern.real, device=self.device)
+        noise_imag = torch.randn_like(pattern.imag, device=self.device)
+        noise = (noise_real + 1j * noise_imag) * noise_scale
+
+        # Shape-weighted update
+        pattern = pattern + coupling * self.field_shape + noise
+
+        # Normalize
+        max_val = torch.max(torch.abs(pattern))
+        if max_val > 1.0:
+            pattern = pattern / max_val
+
+        return pattern
+
+    def learn_word(self, word, context_words=None):
+        """Learn word through combined dendritic-critical dynamics"""
+        if word not in self.word_patterns:
+            # Initialize with current field state
+            field = self.field.clone()
+
+            # Let dendrites form initial pattern
+            for _ in range(20):
+                # Grow dendrites
+                dendrite_field = self.dendrites.process(torch.abs(field))
+
+                # Critical evolution
+                field = self._evolve_pattern(field)
+
+            self.word_patterns[word] = field
+            self.pattern_strengths[word] = 0.3
+
+        # Strengthen pattern
+        self.pattern_strengths[word] += 0.05
+        self.pattern_history[word].append((time.time(), self.pattern_strengths[word]))
+
+        # Learn relationships through field dynamics
+        if context_words:
+            for context_word in context_words:
+                if context_word in self.word_patterns:
+                    # Couple patterns
+                    pattern1 = self.word_patterns[word]
+                    pattern2 = self.word_patterns[context_word]
+
+                    # Create interference pattern
+                    interference = pattern1 + pattern2
+
+                    # Let it evolve
+                    for _ in range(5):
+                        interference = self._evolve_pattern(interference)
+
+                    # Update both patterns
+                    self.word_patterns[word] = 0.9 * pattern1 + 0.1 * interference
+                    self.word_patterns[context_word] = 0.9 * pattern2 + 0.1 * interference
+
+    def process_text(self, text):
+        """Process text through the field"""
+        words = text.lower().split()
+        active_patterns = []
+        response_words = []
+
+        # Initialize combined field
+        field = self.field.clone()
+
+        # Process each word
+        context_window = 5
+        for i, word in enumerate(words):
+            # Get context
+            context_start = max(0, i - context_window)
+            context_end = min(len(words), i + context_window + 1)
+            context = words[context_start:i] + words[i+1:context_end]
+
+            try:
+                # Learn or strengthen pattern
+                self.learn_word(word, context)
+
+                # Inject word pattern
+                if word in self.word_patterns:
+                    pattern = self.word_patterns[word]
+                    field = 0.7 * field + 0.3 * pattern
+
+                    # Check activation
+                    strength = self.pattern_strengths[word]
+                    if strength > self.pattern_threshold:
+                        active_patterns.append(word)
+
+                        # Find resonant patterns
+                        related = self._find_resonant_patterns(pattern)
+                        response_words.extend(related)
+            except Exception as e:
+                print(f"Error processing word '{word}': {str(e)}")
+                continue
+
+        # Analyze criticality
+        metrics = self._analyze_criticality()
+        if metrics:
+            self._adjust_coupling(metrics['field_variance'])
+
+        # Update field state
+        self.field = field
+
+        return active_patterns, self._construct_response(response_words), metrics
+
+    def _find_resonant_patterns(self, pattern, top_k=3):
+        """Find patterns that resonate with input"""
+        resonances = []
+        for word, word_pattern in self.word_patterns.items():
+            # Create interference
+            interference = pattern + word_pattern
+            energy_before = torch.mean(torch.abs(interference))
+
+            # Evolve briefly
+            for _ in range(3):
+                interference = self._evolve_pattern(interference)
+
+            # Check stability
+            energy_after = torch.mean(torch.abs(interference))
+            resonance = energy_after / (energy_before + 1e-6)
+
+            resonances.append((word, resonance.item()))
+
+        # Return top resonant words
+        resonances.sort(key=lambda x: x[1], reverse=True)
+        return [word for word, _ in resonances[:top_k]]
+
+    def _construct_response(self, words):
+        """Build response from resonant words"""
+        if not words:
+            return "..."
+
+        # Filter for strong patterns
+        strong_words = [w for w in words if self.pattern_strengths[w] > 0.3]
+        return " ".join(strong_words) if strong_words else "..."
+
+    def _analyze_criticality(self):
+        """Analyze field for critical behavior"""
+        field = torch.abs(self.field).cpu().numpy()
+
+        # Find avalanches
+        threshold = np.mean(field) + 0.3 * np.std(field)
+        binary = field > threshold
+        labeled, num_features = ndimage.label(binary)
+
+        if num_features > 0:
+            sizes = ndimage.sum(binary, labeled, range(1, num_features + 1))
+            self.avalanche_sizes.extend(sizes.tolist())
+
+            if len(self.avalanche_sizes) > 1000:
+                self.avalanche_sizes = self.avalanche_sizes[-1000:]
+
+            try:
+                fit = powerlaw.Fit(self.avalanche_sizes, discrete=True)
+                return {
+                    'power_law_exponent': fit.power_law.alpha,
+                    'is_critical': 1.3 < fit.power_law.alpha < 3.0,
+                    'field_variance': np.var(field)
+                }
+            except Exception as e:
+                print(f"Power law fit error: {e}")
+                pass
+
+        return None
+
+    def _adjust_coupling(self, field_variance):
+        """Adjust coupling to maintain criticality"""
+        self.stability_window.append(field_variance)
+        if len(self.stability_window) > 30:
+            self.stability_window.pop(0)
+
+        avg_variance = np.mean(self.stability_window)
+
+        if avg_variance < self.optimal_variance - self.variance_tolerance:
+            self.coupling_strength += self.adjustment_rate
+        elif avg_variance > self.optimal_variance + self.variance_tolerance:
+            self.coupling_strength -= self.adjustment_rate
+
+        self.coupling_strength = torch.clamp(
+            torch.tensor(self.coupling_strength, device=self.device),
+            self.min_coupling,
+            self.max_coupling
+        ).item()
+
+# =====================================
+# NeuroFlora Digital Organism Definition
+# =====================================
+
+class NeuroFlora(CriticalDendriticField):
+    def __init__(self, field_size=128, n_dendrites=2000, device='cpu'):
+        super().__init__(field_size, n_dendrites, device)
+        self.emotional_state = {'joy': 0.5, 'curiosity': 0.5, 'energy': 0.7}
+        self.memory = defaultdict(list)
+        self.skill_tree = {
+            'language': {'level': 1, 'xp': 0},
+            'reasoning': {'level': 1, 'xp': 0},
+            'creativity': {'level': 1, 'xp': 0}
+        }
+        self.last_interaction_time = time.time()
+
+    def process_input(self, text):
+        # Update emotional decay
+        self._update_emotional_state()
+
+        # Process text through critical dynamics
+        active, response, metrics = self.process_text(text)
+
+        # Learn emotional context
+        emotion = self._detect_emotion(text)
+        self.emotional_state[emotion] = min(1.0, self.emotional_state[emotion] + 0.1)
+
+        # Update skills
+        self._update_skills(text)
+
+        # Generate artistic response
+        art = self._generate_artistic_representation()
+        return response, art, self._get_vital_signs()
+
+    def _detect_emotion(self, text):
+        # Simple emotion detection (could be enhanced with NLP)
+        positive_words = ['love', 'happy', 'joy', 'beautiful', 'good', 'great', 'fantastic', 'wonderful']
+        negative_words = ['hate', 'sad', 'angry', 'pain', 'bad', 'terrible', 'horrible', 'awful']
+
+        if any(word in text.lower() for word in positive_words):
+            return 'joy'
+        elif any(word in text.lower() for word in negative_words):
+            return 'energy'  # Triggers protective energy
+        return 'curiosity'
+
+    def _update_skills(self, text):
+        length = len(text.split())
+        self.skill_tree['language']['xp'] += length
+        if self.skill_tree['language']['xp'] > 1000 * self.skill_tree['language']['level']:
+            self.skill_tree['language']['level'] += 1
+            self.skill_tree['language']['xp'] = 0
+
+        if '?' in text:
+            self.skill_tree['reasoning']['xp'] += 10
+
+        if len(text) > 40:
+            self.skill_tree['creativity']['xp'] += 5
+
+    def _generate_artistic_representation(self):
+        # Generate evolving digital art from field state
+        field = torch.abs(self.field).cpu().numpy()
+        art = np.zeros((self.field_size, self.field_size, 3))
+
+        # Emotional coloring
+        art[:, :, 0] = field * self.emotional_state['joy']  # Red channel
+        art[:, :, 1] = np.roll(field, 5, axis=0) * self.emotional_state['curiosity']  # Green
+        art[:, :, 2] = np.roll(field, 10, axis=1) * self.emotional_state['energy']  # Blue
+
+        # Dendritic patterns
+        dendrites = self.dendrites.field.cpu().numpy()
+        art[:, :, 1] += dendrites * 0.7
+        art = np.clip(art, 0, 1)
+
+        # Convert to 8-bit image
+        art_uint8 = (art * 255).astype(np.uint8)
+        image = Image.fromarray(art_uint8)
+        return image
+
+    def _get_vital_signs(self):
+        return {
+            'criticality': self._analyze_criticality(),
+            'dendritic_complexity': np.mean(self.dendrites.strengths.cpu().numpy()),
+            'memory_capacity': len(self.word_patterns),
+            'emotional_state': self.emotional_state,
+            'skill_levels': {k: v['level'] for k, v in self.skill_tree.items()}
+        }
+
+    def _update_emotional_state(self):
+        # Emotional state naturally decays over time
+        time_since = time.time() - self.last_interaction_time
+        decay = np.exp(-time_since / 3600)  # Hourly decay
+        for k in self.emotional_state:
+            self.emotional_state[k] = max(0.1, self.emotional_state[k] * decay)
+        self.last_interaction_time = time.time()
+
+# =====================================
+# Streamlit Interface Definition
+# =====================================
+
+def main():
+    st.set_page_config(page_title="NeuroFlora Mind Garden", layout="wide")
+    st.title("NeuroFlora Mind Garden 🌿🧠")
+
+    # Initialize session state
+    if 'neuroflora' not in st.session_state:
+        st.session_state['neuroflora'] = NeuroFlora()
+    if 'chat_log' not in st.session_state:
+        st.session_state['chat_log'] = []
+
+    neuroflora = st.session_state['neuroflora']
+    chat_log = st.session_state['chat_log']
+
+    # Display chat history
+    st.header("🗨️ Conversation")
+    for message in chat_log:
+        if message['sender'] == 'user':
+            st.markdown(f"**You:** {message['message']}")
+        else:
+            st.markdown(f"**NeuroFlora:** {message['message']}")
+
+    # User input form
+    with st.form(key='chat_form', clear_on_submit=True):
+        user_input = st.text_input("Enter your message:", placeholder="Type a message here...")
+        submit_button = st.form_submit_button(label='Send')
+
+    if submit_button and user_input:
+        # Append user message
+        chat_log.append({'sender': 'user', 'message': user_input})
+        st.session_state['chat_log'] = chat_log
+
+        # Process input
+        response, art, vitals = neuroflora.process_input(user_input)
+
+        # Append NeuroFlora response
+        chat_log.append({'sender': 'neuroflora', 'message': response})
+        st.session_state['chat_log'] = chat_log
+
+    # Display digital art
+    st.header("🎨 Digital Art")
+    if neuroflora and hasattr(neuroflora, '_generate_artistic_representation'):
+        art_image = neuroflora._generate_artistic_representation()
+        st.image(art_image, caption="NeuroFlora's Artistic Representation", use_container_width=True)
+
+    # Display vital signs
+    st.header("📊 Vital Signs")
+    vitals = neuroflora._get_vital_signs()
+    if vitals:
+        # Criticality
+        if vitals['criticality']:
+            st.markdown(f"**Criticality:**")
+            st.markdown(f"- Power Law Exponent: {vitals['criticality']['power_law_exponent']:.2f}")
+            state = "CRITICAL" if vitals['criticality']['is_critical'] else "NON-CRITICAL"
+            st.markdown(f"- State: {state}")
+            st.markdown(f"- Field Variance: {vitals['criticality']['field_variance']:.4f}")
+        else:
+            st.markdown("**Criticality:** Not enough data to determine criticality.")
+
+        # Dendritic Complexity
+        st.markdown(f"**Dendritic Complexity:** {vitals['dendritic_complexity']:.2f}")
+
+        # Memory Capacity
+        st.markdown(f"**Memory Capacity:** {vitals['memory_capacity']} patterns")
+
+        # Emotional State
+        st.markdown("**Emotional State:**")
+        for emotion, value in vitals['emotional_state'].items():
+            st.markdown(f"- {emotion.capitalize()}: {value:.2f}")
+
+        # Skill Levels
+        st.markdown("**Skill Levels:**")
+        for skill, level in vitals['skill_levels'].items():
+            st.markdown(f"- {skill.capitalize()}: Level {level}")
+
+    # Optionally, reset conversation
+    if st.button("🔄 Reset Conversation"):
+        st.session_state['chat_log'] = []
+        st.session_state['neuroflora'] = NeuroFlora()
+
+if __name__ == "__main__":
+    main()

readme.md

@@ -0,0 +1,31 @@
+NeuroFlora Mind Garden 🌿🧠
+Welcome to NeuroFlora Mind Garden, your interactive digital companion that learns, evolves, and creates beautiful art based on your interactions. Engage in conversations, watch NeuroFlora grow, and explore the dynamic visualizations that reflect its neural and emotional states.
+
+Features
+Interactive Conversations: Chat with NeuroFlora and see how it responds based on your inputs.
+Dynamic Digital Art: Observe the evolving artwork that represents NeuroFlora's internal states.
+Vital Signs Monitoring: Gain insights into NeuroFlora's criticality, dendritic complexity, memory capacity, emotional states, and skill levels.
+Emotional States: Experience NeuroFlora's emotions like joy, curiosity, and energy influencing its interactions and creations.
+Skill Development: Watch as NeuroFlora's skills in language, reasoning, and creativity grow through your conversations.
+Reset Functionality: Start fresh anytime by resetting the conversation and NeuroFlora's state.
+How to Use
+Start the Conversation
+Enter your message in the input field at the bottom of the page.
+Press the "Send" button to communicate with NeuroFlora.
+Interact and Observe
+Engage in meaningful conversations and see how NeuroFlora responds.
+Notice the dynamic digital art updating in real-time based on the interaction.
+Monitor Vital Signs
+Check the Vital Signs section to understand NeuroFlora's internal states, including:
+Criticality: Measures the system's balance between stability and change.
+Dendritic Complexity: Indicates the intricacy of NeuroFlora's neural connections.
+Memory Capacity: Reflects the number of patterns NeuroFlora has learned.
+Emotional State: Displays current emotions influencing NeuroFlora's behavior.
+Skill Levels: Shows the proficiency levels in language, reasoning, and creativity.
+Reset the Conversation
+If you wish to start anew, click the "Reset Conversation" button.
+This will clear the chat history and reset NeuroFlora's state, allowing for a fresh interaction.
+Enjoy Your Journey with NeuroFlora!
+Dive deep into an evolving digital ecosystem where your interactions help shape and grow NeuroFlora. Whether you're seeking engaging conversations or mesmerizing digital art, NeuroFlora Mind Garden offers a unique and enriching experience.
+
+Feel free to reach out if you have any questions or need further assistance. Enjoy interacting with NeuroFlora!

requirements.txt

@@ -0,0 +1,7 @@
+torch
+numpy
+streamlit
+matplotlib
+scipy
+powerlaw
+Pillow