Create app.py

app.py

@@ -0,0 +1,758 @@
+"""
+Q-Learning AI for Sensor Placement - Interactive Demo
+For Hugging Face Spaces
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+import gradio as gr
+from collections import defaultdict
+
+np.random.seed(42)
+
+
+# ==============================================================================
+# PART 1: THE SECRET WORLD
+# ==============================================================================
+
+class ThiefWorld:
+    """Where thieves REALLY appear (AI must discover this!)"""
+    
+    def __init__(self, hotspot1=2.5, hotspot2=7.0):
+        self.hotspot1 = hotspot1
+        self.hotspot2 = hotspot2
+        self.n_zones = 10
+        
+    def get_thief_probability(self, zone):
+        zone_center = zone + 0.5
+        prob = (
+            0.6 * np.exp(-((zone_center - self.hotspot1)**2) / 1.0) +
+            0.4 * np.exp(-((zone_center - self.hotspot2)**2) / 0.8) +
+            0.05
+        )
+        return min(prob, 1.0)
+    
+    def generate_thieves(self):
+        thieves = np.zeros(self.n_zones)
+        for zone in range(self.n_zones):
+            if np.random.random() < self.get_thief_probability(zone):
+                thieves[zone] = 1
+        return thieves
+
+
+# ==============================================================================
+# PART 2: SENSOR
+# ==============================================================================
+
+class Sensor:
+    def __init__(self, catch_probability=0.9):
+        self.catch_prob = catch_probability
+    
+    def try_catch(self, thief_present):
+        if thief_present:
+            return np.random.random() < self.catch_prob
+        return False
+
+
+# ==============================================================================
+# PART 3: ENVIRONMENT
+# ==============================================================================
+
+class SensorPlacementEnv:
+    def __init__(self, n_sensors=4, hotspot1=2.5, hotspot2=7.0):
+        self.world = ThiefWorld(hotspot1, hotspot2)
+        self.sensor = Sensor()
+        self.n_sensors = n_sensors
+        self.n_zones = 10
+        self.reset()
+        
+    def reset(self):
+        self.zone_attempts = np.zeros(self.n_zones)
+        self.zone_catches = np.zeros(self.n_zones)
+        self.day = 0
+        self.total_caught = 0
+        self.total_thieves = 0
+        return self._get_state()
+    
+    def _get_state(self):
+        if self.zone_attempts.sum() == 0:
+            return (0, 0)
+        most_tried = int(np.argmax(self.zone_attempts))
+        catch_rates = np.zeros(self.n_zones)
+        for z in range(self.n_zones):
+            if self.zone_attempts[z] > 0:
+                catch_rates[z] = self.zone_catches[z] / self.zone_attempts[z]
+        best_zone = int(np.argmax(catch_rates))
+        return (most_tried, best_zone)
+    
+    def step(self, action):
+        thieves = self.world.generate_thieves()
+        n_thieves = int(thieves.sum())
+        self.total_thieves += n_thieves
+        
+        caught = 0
+        for zone in action:
+            if zone < self.n_zones:
+                self.zone_attempts[zone] += 1
+                if thieves[zone] == 1:
+                    if self.sensor.try_catch(True):
+                        caught += 1
+                        self.zone_catches[zone] += 1
+        
+        self.total_caught += caught
+        self.day += 1
+        reward = caught + 0.1 * len(set(action))
+        done = self.day >= 30
+        
+        return self._get_state(), reward, done, {'caught': caught}
+
+
+# ==============================================================================
+# PART 4: Q-LEARNING AGENT
+# ==============================================================================
+
+class QLearningAgent:
+    def __init__(self):
+        self.q_table = defaultdict(lambda: defaultdict(float))
+        self.learning_rate = 0.1
+        self.discount_factor = 0.95
+        self.epsilon = 1.0
+        self.epsilon_decay = 0.995
+        self.epsilon_min = 0.01
+    
+    def _get_possible_actions(self):
+        return [
+            (1, 3, 6, 8), (0, 3, 6, 9), (2, 4, 6, 8),
+            (0, 1, 2, 3), (1, 2, 3, 4), (2, 3, 4, 5),
+            (5, 6, 7, 8), (6, 7, 8, 9), (4, 5, 6, 7),
+            (2, 3, 7, 8), (1, 2, 6, 7), (2, 3, 6, 7),
+            (3, 4, 5, 6), (0, 2, 5, 9), (1, 4, 7, 9),
+        ]
+    
+    def choose_action(self, state):
+        actions = self._get_possible_actions()
+        if np.random.random() < self.epsilon:
+            return actions[np.random.randint(len(actions))]
+        else:
+            best_action = None
+            best_value = -999999
+            for action in actions:
+                value = self.q_table[state][action]
+                if value > best_value:
+                    best_value = value
+                    best_action = action
+            if best_action is None:
+                best_action = actions[np.random.randint(len(actions))]
+            return best_action
+    
+    def learn(self, state, action, reward, next_state, done):
+        old_q = self.q_table[state][action]
+        if done:
+            max_future_q = 0
+        else:
+            actions = self._get_possible_actions()
+            max_future_q = max([self.q_table[next_state][a] for a in actions])
+        target = reward + self.discount_factor * max_future_q
+        new_q = old_q + self.learning_rate * (target - old_q)
+        self.q_table[state][action] = new_q
+    
+    def decay_epsilon(self):
+        self.epsilon = max(self.epsilon_min, self.epsilon * self.epsilon_decay)
+
+
+# ==============================================================================
+# TRAINING AND TESTING FUNCTIONS
+# ==============================================================================
+
+def train_and_test(n_episodes, hotspot1, hotspot2, progress=gr.Progress()):
+    """Train AI and compare with other strategies."""
+    
+    np.random.seed(42)
+    
+    # Training
+    env = SensorPlacementEnv(hotspot1=hotspot1, hotspot2=hotspot2)
+    agent = QLearningAgent()
+    
+    episode_rewards = []
+    episode_catch_rates = []
+    epsilon_history = []
+    
+    for episode in progress.tqdm(range(n_episodes), desc="Training AI"):
+        state = env.reset()
+        total_reward = 0
+        
+        for day in range(30):
+            action = agent.choose_action(state)
+            next_state, reward, done, _ = env.step(action)
+            agent.learn(state, action, reward, next_state, done)
+            state = next_state
+            total_reward += reward
+            if done:
+                break
+        
+        agent.decay_epsilon()
+        episode_rewards.append(total_reward)
+        catch_rate = env.total_caught / max(env.total_thieves, 1) * 100
+        episode_catch_rates.append(catch_rate)
+        epsilon_history.append(agent.epsilon)
+    
+    # Testing
+    n_tests = 50
+    results = {}
+    
+    # Q-Learning AI
+    agent.epsilon = 0
+    catches = []
+    for _ in range(n_tests):
+        state = env.reset()
+        for day in range(30):
+            action = agent.choose_action(state)
+            state, _, done, _ = env.step(action)
+            if done:
+                break
+        catches.append(env.total_caught / max(env.total_thieves, 1) * 100)
+    results['Q-Learning AI'] = np.mean(catches)
+    
+    # Random
+    catches = []
+    for _ in range(n_tests):
+        env.reset()
+        for day in range(30):
+            action = tuple(np.random.choice(10, 4, replace=False))
+            _, _, done, _ = env.step(action)
+            if done:
+                break
+        catches.append(env.total_caught / max(env.total_thieves, 1) * 100)
+    results['Random'] = np.mean(catches)
+    
+    # Static
+    catches = []
+    for _ in range(n_tests):
+        env.reset()
+        for day in range(30):
+            _, _, done, _ = env.step((1, 3, 6, 8))
+            if done:
+                break
+        catches.append(env.total_caught / max(env.total_thieves, 1) * 100)
+    results['Static Uniform'] = np.mean(catches)
+    
+    # Perfect
+    h1_zone = int(hotspot1)
+    h2_zone = int(hotspot2)
+    perfect_action = (h1_zone, h1_zone+1, h2_zone, h2_zone+1)
+    perfect_action = tuple(min(z, 9) for z in perfect_action)
+    catches = []
+    for _ in range(n_tests):
+        env.reset()
+        for day in range(30):
+            _, _, done, _ = env.step(perfect_action)
+            if done:
+                break
+        catches.append(env.total_caught / max(env.total_thieves, 1) * 100)
+    results['Perfect (Cheating)'] = np.mean(catches)
+    
+    # Create plots
+    fig = plt.figure(figsize=(16, 12))
+    
+    # Plot 1: Learning curve
+    ax1 = fig.add_subplot(2, 2, 1)
+    window = max(10, n_episodes // 20)
+    if len(episode_catch_rates) >= window:
+        smoothed = np.convolve(episode_catch_rates, np.ones(window)/window, mode='valid')
+        ax1.plot(episode_catch_rates, alpha=0.3, color='green', label='Raw')
+        ax1.plot(range(window-1, len(episode_catch_rates)), smoothed, 
+                color='green', linewidth=2, label='Smoothed')
+    else:
+        ax1.plot(episode_catch_rates, color='green', linewidth=2)
+    ax1.set_xlabel('Episode', fontsize=12)
+    ax1.set_ylabel('Catch Rate (%)', fontsize=12)
+    ax1.set_title('🎓 AI Learning Progress', fontsize=14)
+    ax1.legend()
+    ax1.grid(True, alpha=0.3)
+    
+    # Plot 2: Epsilon decay
+    ax2 = fig.add_subplot(2, 2, 2)
+    ax2.plot(epsilon_history, color='purple', linewidth=2)
+    ax2.set_xlabel('Episode', fontsize=12)
+    ax2.set_ylabel('Epsilon (Exploration Rate)', fontsize=12)
+    ax2.set_title('🔍 Explore vs Exploit Balance', fontsize=14)
+    ax2.grid(True, alpha=0.3)
+    
+    # Add annotations
+    ax2.annotate('100% Random\n(Exploring)', xy=(0, 1), fontsize=10,
+                xytext=(n_episodes*0.1, 0.8), arrowprops=dict(arrowstyle='->', color='gray'))
+    ax2.annotate('Mostly Using\nKnowledge', xy=(n_episodes-1, epsilon_history[-1]), fontsize=10,
+                xytext=(n_episodes*0.7, 0.3), arrowprops=dict(arrowstyle='->', color='gray'))
+    
+    # Plot 3: What AI learned vs Truth
+    ax3 = fig.add_subplot(2, 2, 3)
+    
+    zone_values = np.zeros(10)
+    zone_counts = np.zeros(10)
+    for state, actions in agent.q_table.items():
+        for action, value in actions.items():
+            for zone in action:
+                zone_values[zone] += value
+                zone_counts[zone] += 1
+    zone_counts[zone_counts == 0] = 1
+    learned = zone_values / zone_counts
+    
+    world = ThiefWorld(hotspot1, hotspot2)
+    truth = [world.get_thief_probability(z) for z in range(10)]
+    
+    x = np.arange(10)
+    width = 0.35
+    ax3.bar(x - width/2, learned / max(learned.max(), 0.01), width, 
+            label='AI Learned', color='blue', alpha=0.7)
+    ax3.bar(x + width/2, np.array(truth) / max(truth), width, 
+            label='True Probability', color='red', alpha=0.7)
+    ax3.axvline(hotspot1, color='red', linestyle='--', alpha=0.5, label=f'Hotspot 1 ({hotspot1})')
+    ax3.axvline(hotspot2, color='darkred', linestyle='--', alpha=0.5, label=f'Hotspot 2 ({hotspot2})')
+    ax3.set_xlabel('Zone', fontsize=12)
+    ax3.set_ylabel('Normalized Value', fontsize=12)
+    ax3.set_title('🧠 Did AI Learn the Truth?', fontsize=14)
+    ax3.legend(loc='upper right')
+    ax3.grid(True, alpha=0.3)
+    ax3.set_xticks(range(10))
+    
+    # Plot 4: Final comparison
+    ax4 = fig.add_subplot(2, 2, 4)
+    names = list(results.keys())
+    values = list(results.values())
+    colors = ['green', 'gray', 'orange', 'blue']
+    bars = ax4.bar(names, values, color=colors, alpha=0.7, edgecolor='black')
+    
+    for bar, val in zip(bars, values):
+        ax4.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 1,
+                f'{val:.1f}%', ha='center', fontsize=12, fontweight='bold')
+    
+    ax4.set_ylabel('Catch Rate (%)', fontsize=12)
+    ax4.set_title('🏆 Final Comparison', fontsize=14)
+    ax4.grid(True, alpha=0.3, axis='y')
+    plt.setp(ax4.xaxis.get_majorticklabels(), rotation=15, ha='right')
+    
+    plt.tight_layout()
+    
+    # Results text
+    results_text = f"""
+## 🎯 Training Complete!
+
+### Training Summary:
+- Episodes trained: **{n_episodes}**
+- Hotspot 1: Zone **{hotspot1}**
+- Hotspot 2: Zone **{hotspot2}**
+- Final exploration rate: **{epsilon_history[-1]*100:.1f}%**
+
+### 📊 Test Results (50 test runs each):
+
+| Strategy | Catch Rate |
+|----------|------------|
+| 🏆 **Q-Learning AI** | **{results['Q-Learning AI']:.1f}%** |
+| Random | {results['Random']:.1f}% |
+| Static Uniform | {results['Static Uniform']:.1f}% |
+| Perfect (Cheating) | {results['Perfect (Cheating)']:.1f}% |
+
+### 🧠 What AI Learned:
+The AI discovered that zones **{int(hotspot1)}** and **{int(hotspot2)}** have more thieves!
+
+### 🎓 Key Insight:
+AI started knowing **NOTHING** and learned through **trial and error**!
+"""
+    
+    return fig, results_text
+
+
+def explain_qlearning():
+    """Create explanation visualization."""
+    
+    fig, axes = plt.subplots(1, 2, figsize=(14, 5))
+    
+    # Plot 1: Q-Learning cycle
+    ax1 = axes[0]
+    ax1.axis('off')
+    
+    # Draw cycle
+    cycle_text = """
+    ┌─────────────────────────────────────────────────────────────┐
+    │                    Q-LEARNING CYCLE                         │
+    │                                                             │
+    │                      ┌─────────┐                            │
+    │                      │  STATE  │                            │
+    │                      │(What AI │                            │
+    │                      │  sees)  │                            │
+    │                      └────┬────┘                            │
+    │                           │                                 │
+    │                           ▼                                 │
+    │    ┌──────────┐     ┌─────────┐     ┌──────────┐           │
+    │    │  UPDATE  │◄────│ ACTION  │────►│  REWARD  │           │
+    │    │ Q-TABLE  │     │(Place   │     │(Caught   │           │
+    │    │(Remember)│     │sensors) │     │thieves?) │           │
+    │    └──────────┘     └─────────┘     └──────────┘           │
+    │         │                                 │                 │
+    │         └─────────────────────────────────┘                 │
+    │                     REPEAT!                                 │
+    └─────────────────────────────────────────────────────────────┘
+    """
+    ax1.text(0.5, 0.5, cycle_text, transform=ax1.transAxes, fontsize=10,
+             verticalalignment='center', horizontalalignment='center',
+             fontfamily='monospace', bbox=dict(boxstyle='round', facecolor='lightyellow'))
+    ax1.set_title('How Q-Learning Works', fontsize=14)
+    
+    # Plot 2: Epsilon explanation
+    ax2 = axes[1]
+    episodes = np.arange(500)
+    epsilon = 1.0 * (0.995 ** episodes)
+    epsilon = np.maximum(epsilon, 0.01)
+    
+    ax2.fill_between(episodes, epsilon, alpha=0.3, color='blue', label='EXPLORE')
+    ax2.fill_between(episodes, 0, 1-epsilon, alpha=0.3, color='green', label='EXPLOIT')
+    ax2.plot(episodes, epsilon, 'b-', linewidth=2)
+    ax2.plot(episodes, 1-epsilon, 'g-', linewidth=2)
+    
+    ax2.axvline(50, color='gray', linestyle='--', alpha=0.5)
+    ax2.axvline(200, color='gray', linestyle='--', alpha=0.5)
+    ax2.axvline(400, color='gray', linestyle='--', alpha=0.5)
+    
+    ax2.text(25, 0.5, 'Early:\n80% Explore', fontsize=9, ha='center')
+    ax2.text(125, 0.5, 'Middle:\n50-50', fontsize=9, ha='center')
+    ax2.text(300, 0.5, 'Late:\n80% Exploit', fontsize=9, ha='center')
+    
+    ax2.set_xlabel('Episode', fontsize=12)
+    ax2.set_ylabel('Probability', fontsize=12)
+    ax2.set_title('Explore vs Exploit Over Time', fontsize=14)
+    ax2.legend(loc='center right')
+    ax2.grid(True, alpha=0.3)
+    
+    plt.tight_layout()
+    return fig
+
+
+def show_environment(hotspot1, hotspot2):
+    """Visualize the thief world."""
+    
+    fig, ax = plt.subplots(figsize=(12, 5))
+    
+    world = ThiefWorld(hotspot1, hotspot2)
+    zones = np.arange(10)
+    probs = [world.get_thief_probability(z) for z in zones]
+    
+    colors = ['red' if p > 0.4 else 'orange' if p > 0.2 else 'green' for p in probs]
+    bars = ax.bar(zones, probs, color=colors, alpha=0.7, edgecolor='black')
+    
+    for bar, prob in zip(bars, probs):
+        ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 0.02,
+               f'{prob*100:.0f}%', ha='center', fontsize=10, fontweight='bold')
+    
+    ax.axvline(hotspot1, color='red', linestyle='--', linewidth=2, label=f'Hotspot 1 ({hotspot1})')
+    ax.axvline(hotspot2, color='darkred', linestyle='--', linewidth=2, label=f'Hotspot 2 ({hotspot2})')
+    
+    ax.set_xlabel('Zone', fontsize=12)
+    ax.set_ylabel('Thief Probability', fontsize=12)
+    ax.set_title('🦹 Secret Thief Locations (AI Must Discover This!)', fontsize=14)
+    ax.set_xticks(zones)
+    ax.legend()
+    ax.grid(True, alpha=0.3, axis='y')
+    
+    plt.tight_layout()
+    return fig
+
+
+def simulate_one_episode(hotspot1, hotspot2):
+    """Simulate and visualize one episode."""
+    
+    np.random.seed(None)  # Random seed for variety
+    
+    env = SensorPlacementEnv(hotspot1=hotspot1, hotspot2=hotspot2)
+    agent = QLearningAgent()
+    agent.epsilon = 0.5  # 50% explore for demo
+    
+    state = env.reset()
+    
+    # Track daily data
+    daily_actions = []
+    daily_caught = []
+    daily_thieves = []
+    
+    for day in range(30):
+        action = agent.choose_action(state)
+        daily_actions.append(action)
+        
+        old_caught = env.total_caught
+        old_thieves = env.total_thieves
+        
+        state, reward, done, info = env.step(action)
+        
+        daily_caught.append(env.total_caught - old_caught)
+        daily_thieves.append(env.total_thieves - old_thieves)
+        
+        agent.learn(state, action, reward, state, done)
+    
+    # Create visualization
+    fig, axes = plt.subplots(2, 2, figsize=(14, 10))
+    
+    # Plot 1: Sensor placements over days
+    ax1 = axes[0, 0]
+    for day, action in enumerate(daily_actions):
+        for zone in action:
+            ax1.scatter(day, zone, c='blue', s=30, alpha=0.6)
+    
+    ax1.axhline(hotspot1, color='red', linestyle='--', alpha=0.5, label=f'Hotspot 1')
+    ax1.axhline(hotspot2, color='darkred', linestyle='--', alpha=0.5, label=f'Hotspot 2')
+    ax1.set_xlabel('Day', fontsize=12)
+    ax1.set_ylabel('Zone', fontsize=12)
+    ax1.set_title('📍 Where AI Placed Sensors Each Day', fontsize=14)
+    ax1.legend()
+    ax1.grid(True, alpha=0.3)
+    ax1.set_yticks(range(10))
+    
+    # Plot 2: Daily catches
+    ax2 = axes[0, 1]
+    days = range(1, 31)
+    ax2.bar(days, daily_caught, color='green', alpha=0.7, label='Caught')
+    ax2.plot(days, daily_thieves, 'ro-', markersize=5, label='Total Thieves')
+    ax2.set_xlabel('Day', fontsize=12)
+    ax2.set_ylabel('Count', fontsize=12)
+    ax2.set_title('🎯 Daily Catches', fontsize=14)
+    ax2.legend()
+    ax2.grid(True, alpha=0.3)
+    
+    # Plot 3: Cumulative performance
+    ax3 = axes[1, 0]
+    cum_caught = np.cumsum(daily_caught)
+    cum_thieves = np.cumsum(daily_thieves)
+    ax3.fill_between(days, cum_caught, alpha=0.3, color='green')
+    ax3.plot(days, cum_caught, 'g-', linewidth=2, label='Cumulative Caught')
+    ax3.plot(days, cum_thieves, 'r--', linewidth=2, label='Cumulative Thieves')
+    ax3.set_xlabel('Day', fontsize=12)
+    ax3.set_ylabel('Cumulative Count', fontsize=12)
+    ax3.set_title('📈 Cumulative Performance', fontsize=14)
+    ax3.legend()
+    ax3.grid(True, alpha=0.3)
+    
+    # Plot 4: Zone usage
+    ax4 = axes[1, 1]
+    zone_usage = np.zeros(10)
+    for action in daily_actions:
+        for zone in action:
+            zone_usage[zone] += 1
+    
+    colors = ['blue' if z in [int(hotspot1), int(hotspot1)+1, int(hotspot2), int(hotspot2)+1] 
+              else 'gray' for z in range(10)]
+    ax4.bar(range(10), zone_usage, color=colors, alpha=0.7, edgecolor='black')
+    ax4.axvline(hotspot1, color='red', linestyle='--', alpha=0.5)
+    ax4.axvline(hotspot2, color='darkred', linestyle='--', alpha=0.5)
+    ax4.set_xlabel('Zone', fontsize=12)
+    ax4.set_ylabel('Times Used', fontsize=12)
+    ax4.set_title('🗺️ Zone Usage (Blue = Near Hotspots)', fontsize=14)
+    ax4.set_xticks(range(10))
+    ax4.grid(True, alpha=0.3, axis='y')
+    
+    plt.tight_layout()
+    
+    # Summary
+    catch_rate = env.total_caught / max(env.total_thieves, 1) * 100
+    summary = f"""
+## 📊 Episode Summary
+
+- **Total Thieves:** {env.total_thieves}
+- **Total Caught:** {env.total_caught}
+- **Catch Rate:** {catch_rate:.1f}%
+
+### Zones Most Used:
+{', '.join([f'Zone {i}' for i in np.argsort(zone_usage)[-3:][::-1]])}
+
+### Note:
+This is just ONE episode with 50% exploration.
+Train for 500+ episodes to see real learning!
+"""
+    
+    return fig, summary
+
+
+# ==============================================================================
+# GRADIO INTERFACE
+# ==============================================================================
+
+with gr.Blocks(title="Q-Learning AI Demo", theme=gr.themes.Soft()) as demo:
+    
+    gr.Markdown("""
+    # 🤖 Q-Learning AI for Sensor Placement
+    
+    **Watch an AI learn where to place sensors to catch thieves!**
+    
+    The AI starts knowing NOTHING and learns through trial-and-error.
+    
+    ---
+    """)
+    
+    with gr.Tabs():
+        
+        # ==== TAB 1: Explanation ====
+        with gr.TabItem("1️⃣ What is Q-Learning?"):
+            gr.Markdown("""
+            ## 🎓 Q-Learning Explained Simply
+            
+            ### Like Teaching a Dog:
+            ```
+            1. Dog tries something → 2. Gets treat (or not) → 3. Remembers → 4. Gets smarter!
+            ```
+            
+            ### For Our AI:
+            ```
+            1. AI places sensors → 2. Catches thieves (reward!) → 3. Updates Q-Table → 4. Gets smarter!
+            ```
+            
+            ### The Q-Table (AI's Memory):
+            
+            | State | Action | Expected Reward |
+            |-------|--------|-----------------|
+            | "Day 1" | Zones (1,3,6,8) | 1.5 points |
+            | "Day 1" | Zones (2,3,7,8) | 3.2 points ← Better! |
+            
+            ### Explore vs Exploit:
+            - **EXPLORE**: Try random things to learn
+            - **EXPLOIT**: Use what you already know
+            
+            Early training → More EXPLORE
+            Late training → More EXPLOIT
+            """)
+            
+            explain_btn = gr.Button("📊 Show Visual Explanation", variant="primary")
+            explain_plot = gr.Plot()
+            explain_btn.click(explain_qlearning, outputs=explain_plot)
+        
+        # ==== TAB 2: Environment ====
+        with gr.TabItem("2️⃣ The Secret World"):
+            gr.Markdown("""
+            ## 🦹 Where Do Thieves Appear?
+            
+            The AI doesn't know this! It must DISCOVER it through learning.
+            
+            Adjust the hotspot locations and see the thief distribution:
+            """)
+            
+            with gr.Row():
+                h1_slider = gr.Slider(0, 9, value=2.5, step=0.5, label="Hotspot 1 Location")
+                h2_slider = gr.Slider(0, 9, value=7.0, step=0.5, label="Hotspot 2 Location")
+            
+            env_btn = gr.Button("🗺️ Show Thief Distribution", variant="primary")
+            env_plot = gr.Plot()
+            env_btn.click(show_environment, [h1_slider, h2_slider], env_plot)
+        
+        # ==== TAB 3: One Episode ====
+        with gr.TabItem("3️⃣ Watch One Episode"):
+            gr.Markdown("""
+            ## 👀 See One Month (30 Days) of Simulation
+            
+            Watch how AI makes decisions and catches thieves.
+            
+            (Note: This is untrained AI with 50% exploration rate)
+            """)
+            
+            with gr.Row():
+                h1_ep = gr.Slider(0, 9, value=2.5, step=0.5, label="Hotspot 1")
+                h2_ep = gr.Slider(0, 9, value=7.0, step=0.5, label="Hotspot 2")
+            
+            ep_btn = gr.Button("▶️ Run One Episode", variant="primary")
+            ep_plot = gr.Plot()
+            ep_summary = gr.Markdown()
+            ep_btn.click(simulate_one_episode, [h1_ep, h2_ep], [ep_plot, ep_summary])
+        
+        # ==== TAB 4: Full Training ====
+        with gr.TabItem("4️⃣ Train the AI!"):
+            gr.Markdown("""
+            ## 🏋️ Train Q-Learning AI
+            
+            Train the AI and compare it against other strategies!
+            
+            ⚠️ Training takes a few seconds depending on episodes.
+            """)
+            
+            with gr.Row():
+                episodes_slider = gr.Slider(100, 1000, value=300, step=50, 
+                                           label="Number of Episodes")
+            
+            with gr.Row():
+                h1_train = gr.Slider(0, 9, value=2.5, step=0.5, label="Hotspot 1")
+                h2_train = gr.Slider(0, 9, value=7.0, step=0.5, label="Hotspot 2")
+            
+            train_btn = gr.Button("🚀 Train AI!", variant="primary", size="lg")
+            
+            train_plot = gr.Plot()
+            train_results = gr.Markdown()
+            
+            train_btn.click(train_and_test, 
+                           [episodes_slider, h1_train, h2_train],
+                           [train_plot, train_results])
+        
+        # ==== TAB 5: Summary ====
+        with gr.TabItem("5️⃣ Key Concepts"):
+            gr.Markdown("""
+            ## 📚 Summary: Q-Learning Key Concepts
+            
+            ### 1. Q-Table
+            ```
+            A "cheat sheet" that stores:
+            "In STATE X, if I do ACTION Y, I expect REWARD Z"
+            ```
+            
+            ### 2. State
+            ```
+            What the AI "sees" at any moment.
+            Example: (most_tried_zone, best_zone_so_far)
+            ```
+            
+            ### 3. Action
+            ```
+            What the AI can do.
+            Example: Place sensors in zones (2, 3, 7, 8)
+            ```
+            
+            ### 4. Reward
+            ```
+            Points for good actions.
+            Example: +1 for each thief caught
+            ```
+            
+            ### 5. Epsilon (ε)
+            ```
+            Exploration rate.
+            ε = 1.0 → 100% random (exploring)
+            ε = 0.01 → 1% random (exploiting knowledge)
+            ```
+            
+            ### 6. Learning Formula
+            ```
+            Q(s,a) = Q(s,a) + α × (reward + γ × max(Q(s',a')) - Q(s,a))
+            
+            In simple terms:
+            New Memory = Old Memory + Learning Rate × (Reality - Expectation)
+            ```
+            
+            ---
+            
+            ## 🎯 Why This Matters
+            
+            This same technique is used in:
+            - 🎮 Game AI (AlphaGo, Chess engines)
+            - 🚗 Self-driving cars
+            - 🤖 Robots
+            - 📱 Recommendation systems
+            
+            **You just learned how real AI works!** 🎓
+            """)
+    
+    gr.Markdown("""
+    ---
+    
+    ### 🔗 About
+    
+    This demo shows **Q-Learning Reinforcement Learning** for sensor placement.
+    
+    The AI learns through trial-and-error, just like humans!
+    """)
+
+
+# Launch
+if __name__ == "__main__":
+    demo.launch()