Update app.py

app.py

@@ -9,6 +9,7 @@ import io
 from PIL import Image
 import os
 import base64
+import copy
 
 os.environ['MPLCONFIGDIR'] = '/tmp/matplotlib'
 
@@ -123,22 +124,115 @@ def bellman_ford(graph, start, goal):
     path.reverse()
     return path if path and path[0] == start else None
 
+def q_learning_train(grid, episodes=1000):
+    """Train Q-Learning model on the grid"""
+    rows, cols = len(grid), len(grid[0])
+    q_values = np.zeros((rows, cols, 4))  # 4 actions: up, right, down, left
+    
+    lr = 0.9
+    gamma = 0.9
+    epsilon = 0.9
+    
+    def is_valid(state):
+        y, x = state
+        return 0 <= x < cols and 0 <= y < rows
+    
+    for episode in range(episodes):
+        # Random start position
+        state = [np.random.randint(rows), np.random.randint(cols)]
+        
+        for _ in range(100):  # Max steps per episode
+            old_state = copy.copy(state)
+            
+            # Epsilon-greedy action selection
+            if np.random.random() > epsilon:
+                action = np.random.randint(4)
+            else:
+                action = np.argmax(q_values[state[0], state[1]])
+            
+            # Apply action (0=up, 1=right, 2=down, 3=left)
+            new_state = copy.copy(state)
+            if action == 0 and state[0] > 0:  # up
+                new_state[0] -= 1
+            elif action == 1 and state[1] < cols - 1:  # right
+                new_state[1] += 1
+            elif action == 2 and state[0] < rows - 1:  # down
+                new_state[0] += 1
+            elif action == 3 and state[1] > 0:  # left
+                new_state[1] -= 1
+            
+            # Calculate reward (negative cost)
+            if is_valid(new_state):
+                reward = -grid[new_state[0]][new_state[1]]
+                state = new_state
+            else:
+                reward = -100  # Penalty for invalid move
+            
+            # Q-Learning update
+            old_q = q_values[old_state[0], old_state[1], action]
+            td = reward + (gamma * np.max(q_values[state[0], state[1]])) - old_q
+            q_values[old_state[0], old_state[1], action] = old_q + (lr * td)
+    
+    return q_values
+
+# Train Q-Learning model once at startup
+print("Training Q-Learning model...")
+Q_VALUES = q_learning_train(GRID)
+print("Q-Learning model trained!")
+
+def q_learning_path(q_values, start, goal, max_steps=100):
+    """Find path using trained Q-Learning model"""
+    current_state = list(start)  # [x, y] format from frontend
+    path = [tuple(current_state)]
+    
+    for _ in range(max_steps):
+        # Convert to [y, x] for q_values indexing
+        y, x = current_state[1], current_state[0]
+        
+        if tuple(current_state) == goal:
+            break
+        
+        # Get best action
+        action = np.argmax(q_values[y, x])
+        
+        # Apply action
+        if action == 0 and y > 0:  # up
+            current_state[1] -= 1
+        elif action == 1 and x < COLS - 1:  # right
+            current_state[0] += 1
+        elif action == 2 and y < ROWS - 1:  # down
+            current_state[1] += 1
+        elif action == 3 and x > 0:  # left
+            current_state[0] -= 1
+        
+        path.append(tuple(current_state))
+        
+        # Prevent infinite loops
+        if len(path) > max_steps:
+            break
+    
+    return path if path[-1] == goal else None
+
 def visualize_path(start_x, start_y, goal_x, goal_y, algorithm):
     start = (int(start_x), int(start_y))
     goal = (int(goal_x), int(goal_y))
     
     if algorithm == "A*":
         path = a_star(GRAPH, start, goal)
-        color = '#00FF00'
+        color = '#0066FF'  # Blue
         title = "A* Algorithm"
     elif algorithm == "Dijkstra":
         path = dijkstra(GRAPH, start, goal)
-        color = '#FFA500'
+        color = '#0066FF'  # Blue
         title = "Dijkstra Algorithm"
-    else:
+    elif algorithm == "Bellman-Ford":
         path = bellman_ford(GRAPH, start, goal)
-        color = '#FF0000'
+        color = '#0066FF'  # Blue
         title = "Bellman-Ford Algorithm"
+    else:  # Q-Learning
+        path = q_learning_path(Q_VALUES, start, goal)
+        color = '#0066FF'  # Blue
+        title = "Q-Learning Algorithm"
     
     # Arka plan resmini yükle - absolute path
     import os
@@ -165,10 +259,10 @@ def visualize_path(start_x, start_y, goal_x, goal_y, algorithm):
     
     # Path'i çiz
     if path:
-        # Path çizgisi
+        # Path çizgisi (mavi)
         path_x = [x + 0.5 for x, y in path]
         path_y = [ROWS - y - 0.5 for x, y in path]
-        ax.plot(path_x, path_y, color=color, linewidth=4, alpha=0.7, zorder=5)
+        ax.plot(path_x, path_y, color='#0066FF', linewidth=4, alpha=0.7, zorder=5)
         
         # Start ve goal noktaları
         for i, (x, y) in enumerate(path):