Spaces:

XBFDI
/

neuron

Runtime error

App Files Files Community

X commited on 25 days ago

Commit

bc069aa

verified ·

1 Parent(s): 49cc9aa

Update app.py

Browse files

Files changed (1) hide show

app.py +430 -267

app.py CHANGED Viewed

@@ -1,8 +1,8 @@
 """
 🧠 AI PLATFORMER + CHATBOT
-Hugging Face Space с настоящей нейросетью
 """
-import gradio as gr
 import numpy as np
 import random
 import json
@@ -14,8 +14,8 @@ from collections import deque
 import torch
 import torch.nn as nn
 import torch.optim as optim
-from PIL import Image
-import io
 # =====================================================
 # 1. НЕЙРОСЕТЬ (DQN)
@@ -62,7 +62,6 @@ class DQNAgent:
         self.optimizer = optim.Adam(self.model.parameters(), lr=self.learning_rate)
         self.criterion = nn.MSELoss()
-        # Загружаем модель если есть
         if os.path.exists('dqn_model.pth'):
             self.load_model()
@@ -377,63 +376,17 @@ class PlatformerLogic:
         reward = 1 + coins_collected * 5
         return self.get_state(), reward, False, sound
-    def render(self):
-        """Рисует игровое поле для Gradio"""
-        grid = np.zeros((self.height, 80, 3), dtype=np.uint8)
-        grid.fill(40)
-        # Небо
-        for y in range(self.ground_level):
-            grid[y, :] = [20, 30, 60]
-        # Земля
-        grid[self.ground_level:self.ground_level+2, :] = [80, 60, 30]
-        # Препятствия
-        for obs in self.obstacles:
-            x = int(obs['x'] - self.player[0] + 40)
-            if obs.get('is_pit', False):
-                for w in range(obs['width']):
-                    if 0 <= x+w < 80:
-                        grid[obs['y']:obs['y']+2, x+w] = [0, 0, 0]
-            else:
-                for w in range(obs['width']):
-                    for h in range(obs['height']):
-                        sx = x + w
-                        sy = obs['y'] + h
-                        if 0 <= sx < 80 and 0 <= sy < self.height:
-                            grid[sy, sx] = [140, 110, 80]
-        # Враги
-        for enemy in self.entities:
-            x = int(enemy['x'] - self.player[0] + 40)
-            y = int(enemy['y'])
-            if 0 <= x < 80 and 0 <= y < self.height:
-                grid[y, x] = [255, 50, 50]
-                if y > 0:
-                    grid[y-1, x] = [200, 30, 30]
-        # Монетки
-        for coin in self.coins:
-            if not coin['collected']:
-                x = int(coin['x'] - self.player[0] + 40)
-                y = int(coin['y'])
-                if 0 <= x < 80 and 0 <= y < self.height:
-                    grid[y, x] = [255, 215, 0]
-        # Игрок
-        if self.alive:
-            px = 40
-            py = int(self.player[1])
-            if 0 <= py < self.height:
-                grid[py, px] = [0, 255, 100]
-                if py > 0:
-                    grid[py-1, px] = [0, 200, 80]
-                if py > 1:
-                    grid[py-2, px] = [0, 150, 60]
-        img = Image.fromarray(grid, 'RGB')
-        return img
 # =====================================================
 # 3. ЧАТ-ПАМЯТЬ
@@ -485,233 +438,443 @@ current_seed = random.randint(0, 999999)
 training_thread = None
 # =====================================================
-# 5. GRADIO ФУНКЦИИ
 # =====================================================
-def game_loop(player_action=0):
-    """Основной игровой цикл"""
     global current_seed, agent
-    # Создаём два экземпляра с одинаковым seed
     ai_env = PlatformerLogic(seed=current_seed)
     player_env = PlatformerLogic(seed=current_seed)
-    ai_state = ai_env.reset()
     player_env.reset()
-    # Делаем несколько шагов
-    ai_alive = True
-    player_alive = True
     for _ in range(5):
-        # Ход ИИ
-        if ai_alive:
-            ai_action = agent.act(ai_state)
-            ai_next_state, _, ai_done, _ = ai_env.step(ai_action)
-            ai_state = ai_next_state
-            ai_alive = not ai_done
-        # Ход игрока
-        if player_alive:
-            _, _, player_done, _ = player_env.step(player_action)
-            player_alive = not player_done
-        if not ai_alive and not player_alive:
             break
-    # Рендерим
-    ai_img = ai_env.render()
-    player_img = player_env.render()
-    return (
-        ai_img,
-        player_img,
-        ai_env.score,
-        player_env.score,
-        player_env.coins_collected,
-        agent.epsilon,
-        agent.best_score
-    )
-def reset_game():
     global current_seed
     current_seed = random.randint(0, 999999)
-    return game_loop(0)
-def move_left():
-    return game_loop(1)
-def move_right():
-    return game_loop(2)
-def move_jump():
-    return game_loop(3)
-def chat_response(message):
-    """Обработчик чата"""
     if message.startswith('/ai '):
-        question = message[4:].strip()
-        if not question:
-            return "❌ Напиши вопрос после /ai"
-        answer = chat_memory.find(question)
-        if answer:
-            return f"🤖 {answer}"
-        return "🤖 Я не знаю ответа. Обучи меня через /data вопрос|ответ"
     elif message.startswith('/data '):
         parts = message[6:].split('|')
         if len(parts) != 2:
-            return "❌ Используй: /data вопрос|ответ"
-        q = parts[0].strip()
-        a = parts[1].strip()
-        return chat_memory.add(q, a)
     elif message == '/stats':
-        return f"""
-📊 **Статистика нейросети:**
-- 🧠 Память: {len(chat_memory.data)} пар
-- 🎮 Шагов обучения: {agent.total_steps}
-- 📉 Эпсилон: {agent.epsilon:.3f}
-- 🏆 Лучший счёт: {agent.best_score}
-- ⚡ Тренируется: {'✅' if is_training else '❌'}
-- 🖥️ Устройство: {agent.device}
-"""
     elif message == '/train':
-        return start_training()
-    elif message == '/save':
-        agent.save_model()
-        return "💾 Модель сохранена!"
-    elif message == '/load':
-        agent.load_model()
-        return "📂 Модель загружена!"
-    else:
-        return """🤖 **Доступные команды:**
-- `/ai вопрос` — задать вопрос
-- `/data вопрос|ответ` — обучить
-- `/stats` — статистика
-- `/train` — тренировка ИИ
-- `/save` — сохранить модель
-- `/load` — загрузить модель"""
-def start_training():
-    """Запускает тренировку в фоновом потоке"""
-    global is_training, training_thread, agent
-    if is_training:
-        return "⏳ Уже тренируется!"
-    is_training = True
-    def train():
-        global is_training, agent
-        try:
-            for ep in range(100):
-                if not is_training:
-                    break
-                score, steps = agent.train_episode()
-                if ep % 10 == 0:
-                    print(f"📊 Episode {ep}: Score={score:.0f}, Epsilon={agent.epsilon:.3f}")
-                if score > 0 and ep % 20 == 0:
-                    agent.save_model()
-        except Exception as e:
-            print(f"❌ Ошибка: {e}")
-        finally:
-            is_training = False
-    training_thread = threading.Thread(target=train)
-    training_thread.start()
-    return "🚀 **Тренировка запущена!** Смотри консоль для прогресса."
-# =====================================================
-# 6. GRADIO INTERFACE
-# =====================================================
-with gr.Blocks(title="🧠 AI Platformer", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("""
-    # 🧠 AI vs Player Platformer
-    ### 🤖 Слева — нейросеть (DQN) играет сама
-    ### 🎮 Справа — ты управляешь зелёным (⬅️ ➡️ ⬆️)
-    ### 💬 Снизу — общий чат с ИИ, который можно обучать!
-    """)
-    with gr.Row():
-        with gr.Column():
-            gr.Markdown("### 🤖 Нейросеть")
-            ai_output = gr.Image(label="AI Game", height=300)
-        with gr.Column():
-            gr.Markdown("### 🎮 Ты")
-            player_output = gr.Image(label="Player Game", height=300)
-    with gr.Row():
-        ai_score = gr.Number(label="🤖 Счёт ИИ", value=0)
-        player_score = gr.Number(label="🎮 Твой счёт", value=0)
-        coins = gr.Number(label="🪙 Монет", value=0)
-        epsilon = gr.Number(label="🧠 Эпсилон", value=1.0)
-        best_score = gr.Number(label="🏆 Рекорд ИИ", value=0)
-    with gr.Row():
-        gr.Markdown("### 🎮 Управление:")
-        left_btn = gr.Button("⬅️ Влево", size="lg")
-        jump_btn = gr.Button("⬆️ Прыжок", size="lg", variant="primary")
-        right_btn = gr.Button("➡️ Вправо", size="lg")
-        reset_btn = gr.Button("🔄 Новый уровень", size="lg", variant="secondary")
-    with gr.Row():
-        train_btn = gr.Button("🧠 Тренировать ИИ", variant="secondary", size="lg")
-        save_btn = gr.Button("💾 Сохранить модель", size="lg")
-        load_btn = gr.Button("📂 Загрузить модель", size="lg")
-        status = gr.Textbox(label="Статус", lines=1)
-    with gr.Tab("💬 Чат с ИИ"):
-        gr.Markdown("""
-        ### Команды:
-        - `/ai <вопрос>` — спросить ИИ
-        - `/data <вопрос>|<ответ>` — обучить ИИ
-        - `/stats` — статистика
-        - `/train` — тренировка
-        - `/save` / `/load` — сохранить/загрузить модель
-        """)
-        chat_input = gr.Textbox(label="Введите команду", placeholder="/ai Как пройти уровень?")
-        chat_output = gr.Markdown(label="Ответ")
-        chat_btn = gr.Button("Отправить", variant="primary")
-    with gr.Accordion("📊 Расширенная статистика", open=False):
-        gr.Markdown("""
-        **Как работает нейросеть:**
-        - 🧠 Архитектура: 4 слоя (256→256→256→128 нейронов)
-        - 📚 Memory: 10000 опыта
-        - 🎯 Алгоритм: DQN с целевой сетью
-        - 📉 Эпсилон-жадность: исследование vs эксплуатация
-        - 🏆 Цель: максимизировать счёт в платформере
-        """)
-        gr.Markdown("*Модель сохраняется автоматически каждые 20 эпизодов*")
-    # Привязка кнопок
-    left_btn.click(move_left, outputs=[ai_output, player_output, ai_score, player_score, coins, epsilon, best_score])
-    right_btn.click(move_right, outputs=[ai_output, player_output, ai_score, player_score, coins, epsilon, best_score])
-    jump_btn.click(move_jump, outputs=[ai_output, player_output, ai_score, player_score, coins, epsilon, best_score])
-    reset_btn.click(reset_game, outputs=[ai_output, player_output, ai_score, player_score, coins, epsilon, best_score])
-    train_btn.click(start_training, outputs=[status])
-    save_btn.click(lambda: agent.save_model() or "💾 Модель сохранена!", outputs=[status])
-    load_btn.click(lambda: agent.load_model() or "📂 Модель загружена!", outputs=[status])
-    chat_btn.click(chat_response, inputs=[chat_input], outputs=[chat_output])
-    chat_input.submit(chat_response, inputs=[chat_input], outputs=[chat_output])
-    # Автозапуск при загрузке
-    demo.load(reset_game, outputs=[ai_output, player_output, ai_score, player_score, coins, epsilon, best_score])
-# =====================================================
-# 7. ЗАПУСК
-# =====================================================
-if __name__ == "__main__":
-    demo.launch(share=True)

 """
 🧠 AI PLATFORMER + CHATBOT
+Hugging Face Space (Flask + HTML)
 """
+from flask import Flask, render_template_string, request, jsonify
 import numpy as np
 import random
 import json
 import torch
 import torch.nn as nn
 import torch.optim as optim
+app = Flask(__name__)
 # =====================================================
 # 1. НЕЙРОСЕТЬ (DQN)
         self.optimizer = optim.Adam(self.model.parameters(), lr=self.learning_rate)
         self.criterion = nn.MSELoss()
         if os.path.exists('dqn_model.pth'):
             self.load_model()
         reward = 1 + coins_collected * 5
         return self.get_state(), reward, False, sound
+    def get_world_data(self):
+        return {
+            'player': self.player,
+            'obstacles': self.obstacles,
+            'entities': self.entities,
+            'coins': [c for c in self.coins if not c['collected']],
+            'ground_level': self.ground_level,
+            'score': self.score,
+            'coins_collected': self.coins_collected,
+            'alive': self.alive
+        }
 # =====================================================
 # 3. ЧАТ-ПАМЯТЬ
 training_thread = None
 # =====================================================
+# 5. HTML
+# =====================================================
+HTML = """
+<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <title>🧠 AI Platformer</title>
+    <style>
+        * { margin: 0; padding: 0; box-sizing: border-box; }
+        body {
+            background: #0a0a1a;
+            color: #eee;
+            font-family: 'Segoe UI', sans-serif;
+            display: flex;
+            justify-content: center;
+            padding: 20px;
+            min-height: 100vh;
+        }
+        .container { max-width: 1100px; width: 100%; }
+        h1 {
+            text-align: center;
+            padding: 15px 0;
+            background: linear-gradient(135deg, #e94560, #0f3460);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            font-size: 2.2em;
+        }
+        .sub { text-align: center; color: #666; margin-bottom: 15px; }
+        .game-row { display: flex; gap: 20px; flex-wrap: wrap; }
+        .game-box {
+            flex: 1; min-width: 300px;
+            background: #16213e;
+            border-radius: 16px;
+            padding: 15px;
+            box-shadow: 0 8px 32px rgba(0,0,0,0.5);
+        }
+        .game-box h3 { text-align: center; margin-bottom: 10px; }
+        canvas {
+            width: 100%; aspect-ratio: 80/20;
+            background: #1a1a2e;
+            border-radius: 8px;
+            display: block;
+            image-rendering: pixelated;
+        }
+        .controls {
+            display: flex; justify-content: center;
+            gap: 12px; margin: 15px 0; flex-wrap: wrap;
+        }
+        .controls button {
+            padding: 12px 30px; font-size: 1.1em;
+            border: none; border-radius: 10px;
+            cursor: pointer; font-weight: bold;
+            transition: all 0.15s; color: white;
+        }
+        .controls button:hover { transform: scale(1.05); }
+        .controls button:active { transform: scale(0.93); }
+        .btn-left { background: #e94560; }
+        .btn-right { background: #e94560; }
+        .btn-jump { background: #0f3460; padding: 12px 45px; }
+        .btn-reset { background: #533483; }
+        .stats-bar {
+            background: #16213e;
+            border-radius: 12px;
+            padding: 12px 20px;
+            margin: 10px 0;
+            display: flex;
+            justify-content: space-around;
+            flex-wrap: wrap;
+            gap: 10px;
+            font-size: 1.1em;
+        }
+        .stats-bar span { color: #e94560; font-weight: bold; }
+        .tabs {
+            display: flex; gap: 10px;
+            margin: 15px 0; flex-wrap: wrap;
+        }
+        .tab {
+            padding: 10px 22px;
+            background: #16213e;
+            border-radius: 10px;
+            cursor: pointer;
+            border: 2px solid transparent;
+            transition: all 0.3s;
+        }
+        .tab:hover { border-color: #e94560; }
+        .tab.active { border-color: #e94560; background: #1a1a3e; }
+        .tab-content {
+            background: #16213e;
+            border-radius: 12px;
+            padding: 20px;
+            min-height: 200px;
+        }
+        .chat-area {
+            display: flex; gap: 10px; margin-top: 10px;
+        }
+        .chat-area input {
+            flex: 1; padding: 10px;
+            border-radius: 8px;
+            border: 1px solid #333;
+            background: #0a0a1a;
+            color: #eee;
+            font-size: 1em;
+        }
+        .chat-area button {
+            padding: 10px 25px;
+            background: #e94560;
+            color: white;
+            border: none;
+            border-radius: 8px;
+            cursor: pointer;
+            font-weight: bold;
+        }
+        .chat-msgs {
+            max-height: 200px;
+            overflow-y: auto;
+            padding: 5px;
+        }
+        .chat-msgs div {
+            padding: 6px 12px;
+            margin: 3px 0;
+            border-radius: 6px;
+            background: #0a0a1a;
+        }
+        .chat-msgs .user { border-left: 3px solid #e94560; }
+        .chat-msgs .bot { border-left: 3px solid #0f3460; }
+        .hidden { display: none; }
+    </style>
+</head>
+<body>
+<div class="container">
+    <h1>🧠 AI vs Player Platformer</h1>
+    <p class="sub">🤖 Нейросеть слева 🎮 Ты справа (⬅️ ➡️ ⬆️)</p>
+    <div class="game-row">
+        <div class="game-box">
+            <h3>🤖 Нейросеть</h3>
+            <canvas id="aiCanvas" width="800" height="200"></canvas>
+        </div>
+        <div class="game-box">
+            <h3>🎮 Ты</h3>
+            <canvas id="playerCanvas" width="800" height="200"></canvas>
+        </div>
+    </div>
+    <div class="stats-bar">
+        <div>🤖 ИИ: <span id="aiScore">0</span></div>
+        <div>🎮 Ты: <span id="playerScore">0</span></div>
+        <div>🪙 Монет: <span id="coinsCount">0</span></div>
+        <div>🧠 Эпсилон: <span id="epsilon">1.00</span></div>
+        <div>🏆 Рекорд: <span id="bestScore">0</span></div>
+    </div>
+    <div class="controls">
+        <button class="btn-left" id="btnLeft">⬅️ Влево</button>
+        <button class="btn-jump" id="btnJump">⬆️ Прыжок</button>
+        <button class="btn-right" id="btnRight">➡️ Вправо</button>
+        <button class="btn-reset" id="btnReset">🔄 Новый уровень</button>
+    </div>
+    <div class="tabs">
+        <div class="tab active" data-tab="chat">💬 Чат</div>
+        <div class="tab" data-tab="train">🧠 Тренировка</div>
+        <div class="tab" data-tab="stats">📊 Статистика</div>
+    </div>
+    <div class="tab-content">
+        <div id="chatTab">
+            <div class="chat-msgs" id="chatMsgs">
+                <div class="bot">🤖 Привет! Команды:</div>
+                <div class="bot"><code>/ai вопрос</code> — спросить</div>
+                <div class="bot"><code>/data вопрос|ответ</code> — обучить</div>
+                <div class="bot"><code>/stats</code> — статистика</div>
+                <div class="bot"><code>/train</code> — тренировка</div>
+            </div>
+            <div class="chat-area">
+                <input id="chatInput" placeholder="Введите команду..." onkeydown="if(event.key==='Enter') sendChat()">
+                <button onclick="sendChat()">➤</button>
+            </div>
+        </div>
+        <div id="trainTab" class="hidden">
+            <h3>🧠 Тренировка нейросети</h3>
+            <p>DQN с 4 слоями (256→256→256→128 нейронов)</p>
+            <button onclick="startTrain()" style="padding:12px 35px;background:#e94560;color:white;border:none;border-radius:10px;font-size:1.1em;cursor:pointer;">
+                🚀 Запустить
+            </button>
+            <div id="trainStatus" style="margin-top:10px;color:#aaa;">⏸ Остановлена</div>
+        </div>
+        <div id="statsTab" class="hidden">
+            <h3>📊 Статистика</h3>
+            <div id="statsContent">Загрузка...</div>
+        </div>
+    </div>
+</div>
+<script>
+let playerAction = 0;
+function drawGame(ctx, data, showPlayer) {
+    const W = ctx.canvas.width, H = ctx.canvas.height;
+    const cellW = W / 80, cellH = H / 20;
+    ctx.clearRect(0, 0, W, H);
+    const grad = ctx.createLinearGradient(0, 0, 0, H);
+    grad.addColorStop(0, '#0a0a2e');
+    grad.addColorStop(0.7, '#1a1a4e');
+    ctx.fillStyle = grad;
+    ctx.fillRect(0, 0, W, H);
+    const cx = data.player[0] - 40;
+    function toScreen(wx, wy) {
+        return [(wx - cx) * cellW, wy * cellH];
+    }
+    const gy = data.ground_level * cellH;
+    ctx.fillStyle = '#4a3a2a';
+    ctx.fillRect(0, gy, W, cellH * 2);
+    ctx.fillStyle = '#3a2a1a';
+    ctx.fillRect(0, gy + cellH * 0.5, W, cellH * 0.5);
+    for (const obs of data.obstacles) {
+        const [x, y] = toScreen(obs.x, obs.y);
+        if (obs.is_pit) {
+            ctx.fillStyle = '#000';
+            ctx.fillRect(x, y - cellH, obs.width * cellW, cellH * 2);
+        } else {
+            ctx.fillStyle = '#8a7a6a';
+            ctx.fillRect(x, y, obs.width * cellW, obs.height * cellH);
+        }
+    }
+    for (const enemy of data.entities) {
+        const [x, y] = toScreen(enemy.x, enemy.y);
+        ctx.fillStyle = '#e94560';
+        ctx.beginPath();
+        ctx.arc(x + cellW/2, y + cellH/2, cellH/2.5, 0, Math.PI*2);
+        ctx.fill();
+    }
+    for (const coin of data.coins) {
+        const [x, y] = toScreen(coin.x, coin.y);
+        ctx.fillStyle = '#ffd700';
+        ctx.beginPath();
+        ctx.arc(x + cellW/2, y + cellH/2, cellH/3, 0, Math.PI*2);
+        ctx.fill();
+    }
+    if (showPlayer && data.alive) {
+        const [px, py] = toScreen(data.player[0], data.player[1]);
+        ctx.fillStyle = '#00ff88';
+        ctx.shadowColor = '#00ff88';
+        ctx.shadowBlur = 15;
+        ctx.fillRect(px + 2, py + 2, cellW - 4, cellH - 4);
+        ctx.shadowBlur = 0;
+    }
+}
+async function updateGame() {
+    try {
+        const res = await fetch('/step', {
+            method: 'POST',
+            headers: {'Content-Type': 'application/json'},
+            body: JSON.stringify({action: playerAction})
+        });
+        const data = await res.json();
+        const aiCanvas = document.getElementById('aiCanvas');
+        const playerCanvas = document.getElementById('playerCanvas');
+        drawGame(aiCanvas.getContext('2d'), data.ai, true);
+        drawGame(playerCanvas.getContext('2d'), data.player, data.player.alive);
+        document.getElementById('aiScore').textContent = data.ai.score;
+        document.getElementById('playerScore').textContent = data.player.score;
+        document.getElementById('coinsCount').textContent = data.player.coins_collected;
+        document.getElementById('epsilon').textContent = data.epsilon.toFixed(3);
+        document.getElementById('bestScore').textContent = data.best_score;
+    } catch(e) {}
+}
+// Управление
+document.getElementById('btnLeft').addEventListener('mousedown', () => { playerAction = 1; });
+document.getElementById('btnLeft').addEventListener('mouseup', () => { playerAction = 0; });
+document.getElementById('btnRight').addEventListener('mousedown', () => { playerAction = 2; });
+document.getElementById('btnRight').addEventListener('mouseup', () => { playerAction = 0; });
+document.getElementById('btnJump').addEventListener('mousedown', () => { playerAction = 3; });
+document.getElementById('btnJump').addEventListener('mouseup', () => { playerAction = 0; });
+document.addEventListener('keydown', (e) => {
+    if (e.key === 'ArrowLeft') { e.preventDefault(); playerAction = 1; }
+    else if (e.key === 'ArrowRight') { e.preventDefault(); playerAction = 2; }
+    else if (e.key === 'ArrowUp' || e.key === ' ') { e.preventDefault(); playerAction = 3; }
+});
+document.addEventListener('keyup', (e) => {
+    if (['ArrowLeft', 'ArrowRight', 'ArrowUp', ' '].includes(e.key)) {
+        e.preventDefault(); playerAction = 0;
+    }
+});
+document.getElementById('btnReset').addEventListener('click', async () => {
+    const res = await fetch('/reset', {method: 'POST'});
+    const data = await res.json();
+    document.getElementById('aiScore').textContent = data.ai.score;
+    document.getElementById('playerScore').textContent = data.player.score;
+    document.getElementById('coinsCount').textContent = data.player.coins_collected;
+});
+// Чат
+async function sendChat() {
+    const input = document.getElementById('chatInput');
+    const msg = input.value.trim();
+    if (!msg) return;
+    input.value = '';
+    const container = document.getElementById('chatMsgs');
+    container.innerHTML += '<div class="user">👤 ' + msg + '</div>';
+    container.scrollTop = container.scrollHeight;
+    const res = await fetch('/chat', {
+        method: 'POST',
+        headers: {'Content-Type': 'application/json'},
+        body: JSON.stringify({message: msg})
+    });
+    const data = await res.json();
+    container.innerHTML += '<div class="bot">🤖 ' + data.response + '</div>';
+    container.scrollTop = container.scrollHeight;
+}
+// Тренировка
+async function startTrain() {
+    document.getElementById('trainStatus').textContent = '⏳ Запуск...';
+    const res = await fetch('/train', {method: 'POST'});
+    const data = await res.json();
+    document.getElementById('trainStatus').textContent = data.message;
+}
+// Табы
+document.querySelectorAll('.tab').forEach(tab => {
+    tab.addEventListener('click', function() {
+        document.querySelectorAll('.tab').forEach(t => t.classList.remove('active'));
+        this.classList.add('active');
+        const tabName = this.dataset.tab;
+        document.querySelectorAll('.tab-content > div').forEach(d => d.classList.add('hidden'));
+        document.getElementById(tabName + 'Tab').classList.remove('hidden');
+        if (tabName === 'stats') {
+            fetch('/stats').then(r => r.json()).then(data => {
+                document.getElementById('statsContent').innerHTML = `
+                    <p>🧠 Память: ${data.memory_size} пар</p>
+                    <p>🎮 Шагов: ${data.steps}</p>
+                    <p>📉 Эпсилон: ${data.epsilon}</p>
+                    <p>🏆 Рекорд: ${data.best_score}</p>
+                    <p>⚡ Тренируется: ${data.training ? '✅' : '❌'}</p>
+                `;
+            });
+        }
+    });
+});
+setInterval(updateGame, 200);
+updateGame();
+</script>
+</body>
+</html>
+"""
+# =====================================================
+# 6. FLASK ROUTES
 # =====================================================
+@app.route('/')
+def index():
+    return render_template_string(HTML)
+@app.route('/step', methods=['POST'])
+def step():
     global current_seed, agent
+    data = request.json
+    player_action = data.get('action', 0)
     ai_env = PlatformerLogic(seed=current_seed)
     player_env = PlatformerLogic(seed=current_seed)
+    ai_env.reset()
     player_env.reset()
     for _ in range(5):
+        if ai_env.alive:
+            ai_action = agent.act(ai_env.get_state())
+            ai_env.step(ai_action)
+        if player_env.alive:
+            player_env.step(player_action)
+        if not ai_env.alive and not player_env.alive:
             break
+    return jsonify({
+        'ai': ai_env.get_world_data(),
+        'player': player_env.get_world_data(),
+        'epsilon': agent.epsilon,
+        'best_score': agent.best_score
+    })
+@app.route('/reset', methods=['POST'])
+def reset():
     global current_seed
     current_seed = random.randint(0, 999999)
+    ai_env = PlatformerLogic(seed=current_seed)
+    player_env = PlatformerLogic(seed=current_seed)
+    ai_env.reset()
+    player_env.reset()
+    return jsonify({
+        'ai': ai_env.get_world_data(),
+        'player': player_env.get_world_data()
+    })
+@app.route('/chat', methods=['POST'])
+def chat():
+    data = request.json
+    message = data.get('message', '').strip()
     if message.startswith('/ai '):
+        q = message[4:].strip()
+        answer = chat_memory.find(q)
+        return jsonify({'response': answer or "🤖 Не знаю. Обучи через /data"})
     elif message.startswith('/data '):
         parts = message[6:].split('|')
         if len(parts) != 2:
+            return jsonify({'response': "❌ Используй: /data вопрос|ответ"})
+        return jsonify({'response': chat_memory.add(parts[0].strip(), parts[1].strip())})
     elif message == '/stats':
+        return jsonify({'response': f"📊 Память: {len(chat_memory.data)} пар, Шагов: {agent.total_steps}"})
     elif message == '/train':
+        return json