Update app.py

app.py

@@ -5,7 +5,7 @@ import matplotlib.pyplot as plt
 from scipy.spatial import distance
 from sklearn.cluster import KMeans
 import networkx as nx
-from collections import deque
+from collections import deque, Counter
 from scipy.signal import convolve2d
 
 # Constants
@@ -27,25 +27,61 @@ env_graph = nx.grid_2d_graph(GRID_SIZE, GRID_SIZE)
 for obstacle in OBSTACLES:
     env_graph.remove_node(obstacle)
 
-# Ant Class
+class HiveMind:
+    def __init__(self):
+        self.collective_memory = {}
+        self.global_strategy = {}
+        self.task_allocation = {}
+        self.pheromone_importance = {'food': 0.5, 'danger': 0.3, 'exploration': 0.2}
+
+    def update_collective_memory(self, ant_memories):
+        for memory in ant_memories:
+            for position, info in memory:
+                if position not in self.collective_memory:
+                    self.collective_memory[position] = info
+                else:
+                    self.collective_memory[position] = (self.collective_memory[position] + info) / 2
+
+    def update_global_strategy(self, ant_performances):
+        best_ants = sorted(ant_performances, key=lambda x: x[1], reverse=True)[:5]
+        self.global_strategy = {
+            'exploration_rate': np.mean([ant.genome['exploration_rate'] for ant, _ in best_ants]),
+            'learning_rate': np.mean([ant.genome['learning_rate'] for ant, _ in best_ants]),
+            'discount_factor': np.mean([ant.genome['discount_factor'] for ant, _ in best_ants])
+        }
+
+    def allocate_tasks(self, ants):
+        ant_positions = [ant.position for ant in ants]
+        clusters = KMeans(n_clusters=min(5, len(ants))).fit(ant_positions)
+        for i, ant in enumerate(ants):
+            cluster = clusters.labels_[i]
+            if cluster not in self.task_allocation:
+                self.task_allocation[cluster] = []
+            self.task_allocation[cluster].append(ant)
+
+    def get_swarm_decision(self, decisions):
+        return Counter(decisions).most_common(1)[0][0]
+
 class Ant:
-    def __init__(self, position, genome):
+    def __init__(self, position, genome, hivemind):
         self.position = position
         self.genome = genome
+        self.hivemind = hivemind
         self.carrying_food = False
         self.energy = 100
         self.memory = deque(maxlen=20)
         self.path_home = []
         self.role = "explorer"
         self.communication_range = 10
-        self.q_table = {}  # Changed to dictionary for flexible indexing
+        self.q_table = {}
+        self.performance = 0
+        self.cluster = None
 
     def perceive_environment(self, pheromone_grid, ants):
         self.food_pheromone = pheromone_grid[self.position[0], self.position[1], 0]
         self.danger_pheromone = pheromone_grid[self.position[0], self.position[1], 1]
         self.exploration_pheromone = pheromone_grid[self.position[0], self.position[1], 2]
         
-        # Perceive nearby ants
         self.nearby_ants = [ant for ant in ants if distance.euclidean(self.position, ant.position) <= self.communication_range]
 
     def act(self, pheromone_grid):
@@ -54,14 +90,26 @@ class Ant:
         if random.random() < self.genome['exploration_rate']:  
             action = random.choice(possible_actions)
         else:
-            q_values = [self.get_q_value(action) for action in possible_actions]
-            action = possible_actions[np.argmax(q_values)]
+            nearby_ants = [ant for ant in self.hivemind.task_allocation.get(self.cluster, []) 
+                           if distance.euclidean(self.position, ant.position) <= self.communication_range]
+            if nearby_ants:
+                swarm_decisions = [ant.decide(pheromone_grid) for ant in nearby_ants]
+                action = self.hivemind.get_swarm_decision(swarm_decisions)
+            else:
+                q_values = [self.get_q_value(action) for action in possible_actions]
+                action = possible_actions[np.argmax(q_values)]
 
         reward = self.calculate_reward()
         self.update_q_table(action, reward)
+        self.performance += reward
 
         return action
 
+    def decide(self, pheromone_grid):
+        possible_actions = self.get_possible_actions()
+        q_values = [self.get_q_value(action) for action in possible_actions]
+        return possible_actions[np.argmax(q_values)]
+
     def get_q_value(self, action):
         return self.q_table.get((self.position, action), 0)
 
@@ -75,14 +123,20 @@ class Ant:
         self.q_table[(self.position, action)] = new_q
 
     def calculate_reward(self):
+        base_reward = -1  # Cost of living
         if self.carrying_food:
-            return 10
-        elif self.position in FOOD_SOURCES:
-            return 20
-        elif self.position in OBSTACLES:
-            return -10
-        else:
-            return -1 + self.food_pheromone - self.danger_pheromone + 0.5 * self.exploration_pheromone
+            base_reward += 10
+        if self.position in FOOD_SOURCES:
+            base_reward += 20
+        if self.position in OBSTACLES:
+            base_reward -= 10
+
+        pheromone_reward = (
+            self.hivemind.pheromone_importance['food'] * self.food_pheromone +
+            self.hivemind.pheromone_importance['danger'] * -self.danger_pheromone +
+            self.hivemind.pheromone_importance['exploration'] * self.exploration_pheromone
+        )
+        return base_reward + pheromone_reward
 
     def get_possible_actions(self):
         x, y = self.position
@@ -118,16 +172,11 @@ class Ant:
         
         pheromone_grid[self.position[0], self.position[1], 2] += 1  # Exploration pheromone
 
-        self.memory.append(self.position)
+        self.memory.append((self.position, (self.food_pheromone, self.danger_pheromone, self.exploration_pheromone)))
+        
+        # Update role based on cluster task
+        self.role = self.hivemind.task_allocation.get(self.cluster, ["explorer"])[0]
         
-        # Update role based on situation
-        if self.carrying_food:
-            self.role = "carrier"
-        elif self.food_pheromone > 5:
-            self.role = "follower"
-        else:
-            self.role = "explorer"
-
         # Path planning
         if self.carrying_food and not self.path_home:
             self.path_home = nx.shortest_path(env_graph, self.position, (0, 0))
@@ -160,9 +209,12 @@ def mutate(genome):
     return genome
 
 # Simulation Loop
-def simulate(ants):
+def simulate(ants, hivemind):
     global pheromone_grid
     food_collected = 0
+    
+    hivemind.allocate_tasks(ants)
+    
     for ant in ants:
         if ant.update(pheromone_grid, ants):
             if ant.position == (0, 0) and not ant.carrying_food:
@@ -171,28 +223,25 @@ def simulate(ants):
     pheromone_grid *= (1 - PHEROMONE_DECAY_RATE)
     diffuse_pheromones(pheromone_grid)
 
-    # Genetic Algorithm
+    hivemind.update_collective_memory([ant.memory for ant in ants])
+    hivemind.update_global_strategy([(ant, ant.performance) for ant in ants])
+
+    # Genetic Algorithm and Swarm Adaptation
     if len(ants) > MAX_ANTS:
-        ants.sort(key=lambda x: x.energy, reverse=True)
+        ants.sort(key=lambda x: x.performance, reverse=True)
         survivors = ants[:MAX_ANTS//2]
         new_ants = []
         while len(new_ants) < MAX_ANTS//2:
             parent1, parent2 = random.sample(survivors, 2)
             child_genome = crossover(parent1.genome, parent2.genome)
             child_genome = mutate(child_genome)
-            new_ant = Ant((random.randint(0, GRID_SIZE-1), random.randint(0, GRID_SIZE-1)), child_genome)
+            child_genome = {**child_genome, **hivemind.global_strategy}  # Incorporate global strategy
+            new_ant = Ant((random.randint(0, GRID_SIZE-1), random.randint(0, GRID_SIZE-1)), child_genome, hivemind)
             new_ants.append(new_ant)
         ants = survivors + new_ants
     
     return ants, food_collected
 
-# Clustering for strategic analysis
-def analyze_ant_clusters(ants):
-    positions = np.array([ant.position for ant in ants])
-    kmeans = KMeans(n_clusters=3)
-    kmeans.fit(positions)
-    return kmeans.cluster_centers_
-
 # Visualization Functions
 def plot_environment(pheromone_grid, ants, cluster_centers):
     fig, ax = plt.subplots(figsize=(10, 10))
@@ -225,11 +274,13 @@ exploration_rate = st.sidebar.slider("Exploration Rate", 0.0, 1.0, 0.2)
 learning_rate = st.sidebar.slider("Learning Rate", 0.0, 1.0, 0.1)
 discount_factor = st.sidebar.slider("Discount Factor", 0.0, 1.0, 0.9)
 
-# Initialize ants
+# Initialize hivemind and ants
+hivemind = HiveMind()
 ants = [Ant((random.randint(0, GRID_SIZE-1), random.randint(0, GRID_SIZE-1)), 
             {'exploration_rate': exploration_rate, 
              'learning_rate': learning_rate, 
-             'discount_factor': discount_factor}) 
+             'discount_factor': discount_factor},
+            hivemind) 
         for _ in range(num_ants)]
 
 # Simulation control
@@ -250,12 +301,12 @@ if start_simulation:
     plot_placeholder = st.empty()
     
     while not stop_simulation:
-        ants, food_collected = simulate(ants)
+        ants, food_collected = simulate(ants, hivemind)
         total_food_collected += food_collected
         iterations += 1
         
         if iterations % 10 == 0:
-            cluster_centers = analyze_ant_clusters(ants)
+            cluster_centers = hivemind.allocate_tasks(ants)
         
         if iterations % 5 == 0:
             progress_bar.progress(min(iterations / 1000, 1.0))
@@ -266,10 +317,12 @@ if start_simulation:
 
 if reset_simulation:
     pheromone_grid = np.zeros((GRID_SIZE, GRID_SIZE, 3))
+    hivemind = HiveMind()
     ants = [Ant((random.randint(0, GRID_SIZE-1), random.randint(0, GRID_SIZE-1)), 
                 {'exploration_rate': exploration_rate, 
                  'learning_rate': learning_rate, 
-                 'discount_factor': discount_factor}) 
+                 'discount_factor': discount_factor},
+                hivemind) 
             for _ in range(num_ants)]
     total_food_collected = 0
     iterations = 0
@@ -304,4 +357,51 @@ if iterations > 0:
     fig, ax = plt.subplots(figsize=(10, 10))
     pos = nx.spring_layout(G)
     nx.draw(G, pos, with_labels=False, node_size=30, node_color='skyblue', edge_color='gray', ax=ax)
-    st.pyplot(fig)
+    st.pyplot(fig)
+
+    # Display hivemind collective memory heatmap
+    st.write("## Hivemind Collective Memory")
+    memory_grid = np.zeros((GRID_SIZE, GRID_SIZE))
+    for pos, info in hivemind.collective_memory.items():
+        memory_grid[pos[0], pos[1]] = np.mean(info)
+    
+    fig, ax = plt.subplots(figsize=(10, 10))
+    heatmap = ax.imshow(memory_grid, cmap='viridis', interpolation='nearest')
+    plt.colorbar(heatmap)
+    st.pyplot(fig)
+
+    # Display global strategy evolution
+    st.write("## Global Strategy Evolution")
+    strategy_df = pd.DataFrame(hivemind.global_strategy, index=[0])
+    st.line_chart(strategy_df)
+
+    # Display performance distribution of ants
+    st.write("## Ant Performance Distribution")
+    performances = [ant.performance for ant in ants]
+    fig, ax = plt.subplots()
+    ax.hist(performances, bins=20)
+    ax.set_xlabel('Performance')
+    ax.set_ylabel('Number of Ants')
+    st.pyplot(fig)
+
+    # Display task allocation
+    st.write("## Task Allocation")
+    task_df = pd.DataFrame.from_dict(hivemind.task_allocation, orient='index')
+    task_df = task_df.applymap(lambda x: len(x) if x else 0)
+    st.bar_chart(task_df)
+
+# Add some final notes about the simulation
+st.write("""
+## About this Simulation
+
+This advanced ant hivemind simulation demonstrates several key concepts in swarm intelligence and collective behavior:
+
+1. **Collective Decision Making**: Ants make decisions based on both individual and swarm intelligence.
+2. **Adaptive Strategies**: The hivemind evolves its strategy based on the performance of the best ants.
+3. **Distributed Task Allocation**: Ants are dynamically assigned to different tasks based on their location and the colony's needs.
+4. **Emergent Behavior**: Complex colony-level behaviors emerge from simple individual ant rules.
+5. **Information Sharing**: Ants share information through pheromones and direct communication.
+6. **Collective Memory**: The hivemind maintains a collective memory of the environment.
+
+This simulation showcases how simple agents, when working together with the right rules, can exhibit complex and intelligent behavior at the group level.
+""")