Update app.py

app.py

@@ -1,12 +1,13 @@
 """
-AI PLATFORMER + CHATBOT (RICH GRAPHICS + FIXED PHYSICS)
-AABB Collision, Detailed Rendering, Stateful Engine
+AI PLATFORMER + NEURAL CHATBOT (FROM SCRATCH)
+Custom PyTorch NLP model, AABB physics, rich graphics
+No external NLP libraries - everything built from zero
 """
 
-import os, json, random, threading, logging, time
-from collections import deque
+import os, json, random, threading, logging, time, re, math
+from collections import deque, Counter
 from dataclasses import dataclass
-from typing import Dict, List, Optional
+from typing import Dict, List, Optional, Tuple
 import numpy as np
 import torch
 import torch.nn as nn
@@ -25,11 +26,314 @@ class Cfg:
     BATCH: int = 64; GAMMA: float = 0.99; LR: float = 5e-4
     EPS_DEC: float = 0.995; PORT: int = 7860
     MODEL: str = "dqn_model.pth"; CHAT: str = "chat_data.json"
+    # Chat NN config
+    VOCAB_MAX: int = 2000; EMB_DIM: int = 64; HIDDEN: int = 128
+    CHAT_LR: float = 1e-3; CHAT_EPOCHS: int = 80; SIM_THRESH: float = 0.5
 
 C = Cfg()
 
 # ============================================================================
-# GAME ENGINE: AABB PHYSICS + RICH WORLD
+# CUSTOM TOKENIZER (From Scratch)
+# ============================================================================
+
+class Tokenizer:
+    """Simple character-ngram + word tokenizer built from zero."""
+    
+    PAD = "<PAD>"; UNK = "<UNK>"
+    
+    def __init__(self, max_vocab: int = 2000):
+        self.max_vocab = max_vocab
+        self.word2idx: Dict[str, int] = {self.PAD: 0, self.UNK: 1}
+        self.idx2word: Dict[int, str] = {0: self.PAD, 1: self.UNK}
+        self.frozen = False
+    
+    def _tokenize(self, text: str) -> List[str]:
+        text = text.lower().strip()
+        text = re.sub(r'[^\w\sа-яё]', ' ', text)
+        words = text.split()
+        # Add char bigrams for fuzzy matching
+        tokens = []
+        for w in words:
+            tokens.append(w)
+            if len(w) > 2:
+                tokens.extend([w[i:i+2] for i in range(len(w)-1)])
+        return tokens
+    
+    def build_vocab(self, texts: List[str]):
+        counter = Counter()
+        for t in texts:
+            counter.update(self._tokenize(t))
+        
+        most_common = counter.most_common(self.max_vocab - 2)
+        for word, _ in most_common:
+            idx = len(self.word2idx)
+            self.word2idx[word] = idx
+            self.idx2word[idx] = word
+        
+        self.frozen = True
+        logger.info(f"📝 Vocab built: {len(self.word2idx)} tokens")
+    
+    def encode(self, text: str, max_len: int = 32) -> List[int]:
+        tokens = self._tokenize(text)[:max_len]
+        ids = [self.word2idx.get(t, 1) for t in tokens]
+        # Pad
+        ids += [0] * (max_len - len(ids))
+        return ids
+    
+    @property
+    def vocab_size(self) -> int:
+        return len(self.word2idx)
+
+
+# ============================================================================
+# NEURAL CHAT MODEL (From Scratch)
+# ============================================================================
+
+class ChatEncoder(nn.Module):
+    """Encodes text into semantic embedding vector."""
+    
+    def __init__(self, vocab_size: int, emb_dim: int, hidden: int, out_dim: int):
+        super().__init__()
+        self.embedding = nn.Embedding(vocab_size, emb_dim, padding_idx=0)
+        self.fc1 = nn.Linear(emb_dim, hidden)
+        self.fc2 = nn.Linear(hidden, hidden)
+        self.fc3 = nn.Linear(hidden, out_dim)
+        self.relu = nn.ReLU()
+        self.dropout = nn.Dropout(0.2)
+        self.ln1 = nn.LayerNorm(hidden)
+        self.ln2 = nn.LayerNorm(hidden)
+    
+    def forward(self, x):
+        # x: (batch, seq_len)
+        emb = self.embedding(x)          # (batch, seq_len, emb_dim)
+        # Mean pooling over sequence (ignore padding)
+        mask = (x != 0).unsqueeze(-1).float()  # (batch, seq_len, 1)
+        pooled = (emb * mask).sum(dim=1) / mask.sum(dim=1).clamp(min=1)  # (batch, emb_dim)
+        
+        h = self.ln1(self.fc1(pooled))
+        h = self.relu(h)
+        h = self.dropout(h)
+        h = self.ln2(self.fc2(h))
+        h = self.relu(h)
+        h = self.dropout(h)
+        out = self.fc3(h)
+        # L2 normalize for cosine similarity
+        return nn.functional.normalize(out, p=2, dim=-1)
+
+
+class NeuralChat:
+    """Chat system with custom-trained neural network."""
+    
+    SEQ_LEN = 32
+    OUT_DIM = 64
+    
+    def __init__(self):
+        self.tokenizer = Tokenizer(C.VOCAB_MAX)
+        self.data: Dict[str, str] = {}
+        self.questions: List[str] = []
+        self.q_embeddings: Optional[torch.Tensor] = None
+        self.model: Optional[ChatEncoder] = None
+        self.device = torch.device('cpu')
+        
+        self._load_data()
+        self._build_and_train()
+        logger.info(f"✅ Neural chat ready. {len(self.data)} entries.")
+    
+    def _load_data(self):
+        if os.path.exists(C.CHAT):
+            try:
+                with open(C.CHAT, 'r', encoding='utf-8') as f:
+                    self.data = json.load(f)
+            except Exception as e:
+                logger.warning(f"⚠️ Chat load failed: {e}")
+        
+        if not self.data:
+            self.data = {
+                "как играть": "Стрелки ⬅️➡️ для движения, ⬆️/Пробел для прыжка",
+                "что делает нейросеть": "DQN учится играть методом проб и ошибок, получая награду за монеты",
+                "как обучить бота": "Напиши /data вопрос|ответ чтобы добавить знание",
+                "какой алгоритм": "Deep Q-Network с replay buffer и target network",
+                "зачем эпсилон": "Epsilon-greedy: чем выше ε, тем больше случайных действий для исследования",
+                "как сбросить уровень": "Нажми 🔄 Новый уровень",
+                "что такое dqn": "Deep Q-Network предсказывает ценность каждого действия в состоянии",
+                "сколько нейронов": "1600→256→256→128→4 (вход=40x40 сетка)",
+                "привет": "Привет! Я нейросетевой чат-бот платформера 🧠",
+                "как работает чат": "Я использую кастомную нейросеть на PyTorch с эмбеддингами и косинусным сходством",
+                "кто тебя создал": "Я написан с нуля на PyTorch без внешних NLP библиотек",
+            }
+            self._save_data()
+    
+    def _save_data(self):
+        with open(C.CHAT, 'w', encoding='utf-8') as f:
+            json.dump(self.data, f, ensure_ascii=False, indent=2)
+    
+    def _build_and_train(self):
+        """Build vocab, create model, train on existing data."""
+        self.questions = list(self.data.keys())
+        
+        if not self.questions:
+            return
+        
+        # Build vocabulary from all questions
+        self.tokenizer.build_vocab(self.questions)
+        
+        # Create model
+        self.model = ChatEncoder(
+            vocab_size=self.tokenizer.vocab_size,
+            emb_dim=C.EMB_DIM,
+            hidden=C.HIDDEN,
+            out_dim=self.OUT_DIM
+        ).to(self.device)
+        
+        # Train on question pairs (contrastive learning)
+        self._train_model()
+        
+        # Pre-compute embeddings
+        self._update_index()
+    
+    def _train_model(self):
+        """Train encoder using contrastive loss on question pairs."""
+        if len(self.questions) < 2:
+            # Not enough data to train meaningfully, use untrained model
+            logger.warning("⚠️ Too few entries to train, using untrained embeddings")
+            return
+        
+        optimizer = optim.Adam(self.model.parameters(), lr=C.CHAT_LR)
+        
+        # Encode all questions
+        q_ids = torch.LongTensor([
+            self.tokenizer.encode(q, self.SEQ_LEN) for q in self.questions
+        ]).to(self.device)
+        
+        n = len(self.questions)
+        best_loss = float('inf')
+        
+        logger.info(f"🧠 Training chat NN: {n} samples, {C.CHAT_EPOCHS} epochs...")
+        
+        for epoch in range(C.CHAT_EPOCHS):
+            total_loss = 0.0
+            num_pairs = 0
+            
+            # For each question, positive = itself, negative = random other
+            indices = list(range(n))
+            random.shuffle(indices)
+            
+            for i in indices:
+                anchor = q_ids[i:i+1]      # (1, seq)
+                positive = q_ids[i:i+1]     # same question
+                
+                # Pick negative (different question)
+                neg_idx = random.choice([j for j in range(n) if j != i])
+                negative = q_ids[neg_idx:neg_idx+1]
+                
+                emb_a = self.model(anchor)     # (1, out_dim)
+                emb_p = self.model(positive)   # (1, out_dim)
+                emb_n = self.model(negative)   # (1, out_dim)
+                
+                # Cosine similarity
+                pos_sim = nn.functional.cosine_similarity(emb_a, emb_p)
+                neg_sim = nn.functional.cosine_similarity(emb_a, emb_n)
+                
+                # Contrastive loss: maximize pos_sim, minimize neg_sim
+                margin = 0.3
+                loss = torch.relu(margin - pos_sim + neg_sim).mean()
+                
+                optimizer.zero_grad()
+                loss.backward()
+                optimizer.step()
+                
+                total_loss += loss.item()
+                num_pairs += 1
+            
+            avg_loss = total_loss / max(num_pairs, 1)
+            if avg_loss < best_loss:
+                best_loss = avg_loss
+            
+            if (epoch + 1) % 20 == 0:
+                logger.info(f"  Epoch {epoch+1}/{C.CHAT_EPOCHS}, loss={avg_loss:.4f}")
+        
+        logger.info(f"✅ Chat training complete. Best loss: {best_loss:.4f}")
+    
+    def _update_index(self):
+        """Pre-compute embeddings for all stored questions."""
+        if not self.questions or self.model is None:
+            self.q_embeddings = None
+            return
+        
+        self.model.eval()
+        with torch.no_grad():
+            ids = torch.LongTensor([
+                self.tokenizer.encode(q, self.SEQ_LEN) for q in self.questions
+            ]).to(self.device)
+            self.q_embeddings = self.model(ids)  # (n, out_dim)
+        self.model.train()
+    
+    def ask(self, query: str) -> str:
+        """Semantic search using trained neural embeddings."""
+        if not self.questions or self.q_embeddings is None:
+            return "🤖 База пуста. Обучи меня: /data вопрос|ответ"
+        
+        self.model.eval()
+        with torch.no_grad():
+            q_id = torch.LongTensor([self.tokenizer.encode(query, self.SEQ_LEN)]).to(self.device)
+            q_emb = self.model(q_id)  # (1, out_dim)
+            
+            # Cosine similarity against all stored questions
+            sims = nn.functional.cosine_similarity(q_emb, self.q_embeddings)
+            best_idx = torch.argmax(sims).item()
+            best_score = sims[best_idx].item()
+        
+        self.model.train()
+        
+        if best_score >= C.SIM_THRESH:
+            conf = int(best_score * 100)
+            return f"{self.data[self.questions[best_idx]]} (🧠 {conf}%)"
+        
+        return f"🤖 Не знаю «{query}». Научи: /data {query}|ответ"
+    
+    def teach(self, question: str, answer: str) -> str:
+        """Add knowledge and retrain incrementally."""
+        question = question.strip().lower()
+        answer = answer.strip()
+        
+        if not question or not answer:
+            return "❌ Формат: /data вопрос|ответ"
+        
+        is_new = question not in self.data
+        self.data[question] = answer
+        self._save_data()
+        
+        # Rebuild everything
+        self.questions = list(self.data.keys())
+        self.tokenizer = Tokenizer(C.VOCAB_MAX)
+        self.tokenizer.build_vocab(self.questions)
+        
+        self.model = ChatEncoder(
+            vocab_size=self.tokenizer.vocab_size,
+            emb_dim=C.EMB_DIM,
+            hidden=C.HIDDEN,
+            out_dim=self.OUT_DIM
+        ).to(self.device)
+        
+        self._train_model()
+        self._update_index()
+        
+        action = "Добавлено" if is_new else "Обновлено"
+        return f"✅ {action}: «{question}» → «{answer}». Модель переобучена."
+    
+    @property
+    def stats(self) -> dict:
+        params = sum(p.numel() for p in self.model.parameters()) if self.model else 0
+        return {
+            'entries': len(self.data),
+            'vocab': self.tokenizer.vocab_size,
+            'params': params,
+            'emb_dim': self.OUT_DIM
+        }
+
+
+# ============================================================================
+# GAME ENGINE (AABB Physics + Rich Graphics)
 # ============================================================================
 
 class Engine:
@@ -79,11 +383,7 @@ class Engine:
                 })
 
         for _ in range(rng.randint(5, 10) + int(diff)):
-            cns.append({
-                'x': bx + rng.randint(2, 28),
-                'y': rng.randint(5, C.GROUND - 2),
-                'collected': False
-            })
+            cns.append({'x': bx + rng.randint(2, 28), 'y': rng.randint(5, C.GROUND - 2), 'collected': False})
         return {'obs': obs, 'ens': ens, 'cns': cns}
 
     def _load_chunks(self):
@@ -91,7 +391,6 @@ class Engine:
         for i in range(cc - 1, cc + 3):
             if i not in self.chunks:
                 self.chunks[i] = self._gen_chunk(i)
-
         vl, vr = self.px - C.W / 2, self.px + C.W / 2
         self.obs, self.enemies, self.coin_list = [], [], []
         for i in range(cc - 1, cc + 3):
@@ -114,94 +413,58 @@ class Engine:
             for ww in range(o.get('w', 1)):
                 for hh in range(o.get('h', 1)):
                     sx, sy = h + dx + ww, h + dy + hh
-                    if 0 <= sx < C.VIEW and 0 <= sy < C.VIEW:
-                        s[sy, sx] = v
+                    if 0 <= sx < C.VIEW and 0 <= sy < C.VIEW: s[sy, sx] = v
         for e in self.enemies:
             dx, dy = int(round(e['x'])) - px, int(round(e['y'])) - py
-            if 0 <= h + dx < C.VIEW and 0 <= h + dy < C.VIEW:
-                s[h + dy, h + dx] = 0.7
+            if 0 <= h + dx < C.VIEW and 0 <= h + dy < C.VIEW: s[h + dy, h + dx] = 0.7
         for c in self.coin_list:
             dx, dy = int(round(c['x'])) - px, int(round(c['y'])) - py
-            if 0 <= h + dx < C.VIEW and 0 <= h + dy < C.VIEW:
-                s[h + dy, h + dx] = 0.3
+            if 0 <= h + dx < C.VIEW and 0 <= h + dy < C.VIEW: s[h + dy, h + dx] = 0.3
         return s.flatten()
 
     def step(self, action: int):
         sound = None
-        PW, PH = 0.6, 0.9  # Player hitbox size
-
-        # Input
+        PW, PH = 0.6, 0.9
         self.vx = 0.0
         if action == 1: self.vx = -C.SPEED
         elif action == 2: self.vx = C.SPEED
         if action == 3 and self.grounded:
-            self.vy = C.JUMP
-            self.grounded = False
-            sound = 'jump'
+            self.vy = C.JUMP; self.grounded = False; sound = 'jump'
 
-        # === X AXIS MOVEMENT + COLLISION ===
+        # X axis
         self.px += self.vx
         for o in self.obs:
             if o.get('pit'): continue
             if self._aabb(self.px, self.py, PW, PH, o['x'], o['y'], o['w'], o['h']):
-                if self.vx > 0:
-                    self.px = o['x'] - PW
-                elif self.vx < 0:
-                    self.px = o['x'] + o['w']
+                if self.vx > 0: self.px = o['x'] - PW
+                elif self.vx < 0: self.px = o['x'] + o['w']
                 self.vx = 0
 
-        # === Y AXIS MOVEMENT + COLLISION ===
-        self.vy += C.GRAV
-        self.py += self.vy
-        self.grounded = False
-
-        # Ground collision
+        # Y axis
+        self.vy += C.GRAV; self.py += self.vy; self.grounded = False
         if self.py >= C.GROUND:
-            self.py = C.GROUND
-            self.vy = 0.0
-            self.grounded = True
-
-        # Platform collision (Y)
+            self.py = C.GROUND; self.vy = 0.0; self.grounded = True
         for o in self.obs:
             if o.get('pit'): continue
             if self._aabb(self.px, self.py, PW, PH, o['x'], o['y'], o['w'], o['h']):
-                if self.vy > 0:  # Falling down onto platform
-                    self.py = o['y'] - PH
-                    self.vy = 0.0
-                    self.grounded = True
-                elif self.vy < 0:  # Jumping up into platform
-                    self.py = o['y'] + o['h']
-                    self.vy = 0.0
-
-        # Death: fell off world
-        if self.py > C.H + 2:
-            self.alive = False
-            return self.get_state(), -50.0, True, 'die'
+                if self.vy > 0: self.py = o['y'] - PH; self.vy = 0.0; self.grounded = True
+                elif self.vy < 0: self.py = o['y'] + o['h']; self.vy = 0.0
 
-        # Pit death
+        if self.py > C.H + 2:
+            self.alive = False; return self.get_state(), -50.0, True, 'die'
         for o in self.obs:
             if o.get('pit') and o['x'] <= self.px + PW / 2 <= o['x'] + o['w'] and self.py >= C.GROUND:
-                self.alive = False
-                return self.get_state(), -50.0, True, 'die'
-
-        # Enemy collision
+                self.alive = False; return self.get_state(), -50.0, True, 'die'
         for e in self.enemies:
             if self._aabb(self.px, self.py, PW, PH, e['x'] - 0.3, e['y'] - 0.3, 0.6, 0.6):
-                self.alive = False
-                return self.get_state(), -50.0, True, 'die'
+                self.alive = False; return self.get_state(), -50.0, True, 'die'
 
-        # Coins
         got = 0
         for c in self.coin_list:
             if not c['collected'] and self._aabb(self.px, self.py, PW, PH, c['x'] - 0.3, c['y'] - 0.3, 0.6, 0.6):
-                c['collected'] = True
-                got += 1
-        if got:
-            self.coins += got
-            self.score += got * 10
-            sound = 'coin'
-
-        # Update enemies
+                c['collected'] = True; got += 1
+        if got: self.coins += got; self.score += got * 10; sound = 'coin'
+
         t = time.time()
         for e in self.enemies:
             if e['type'] == 'walker':
@@ -210,24 +473,17 @@ class Engine:
             else:
                 e['y'] = (C.GROUND - 1) + np.sin(t * e['spd'] * 3) * 0.5
 
-        self.score += 1
-        self.step_n += 1
-        self._load_chunks()
-
+        self.score += 1; self.step_n += 1; self._load_chunks()
         done = self.step_n > 3000
-        reward = 1.0 + got * 5.0
-        return self.get_state(), reward, done, sound
+        return self.get_state(), 1.0 + got * 5.0, done, sound
 
     def world_data(self):
         return {
             'player': [round(self.px, 2), round(self.py, 2)],
-            'obstacles': self.obs,
-            'entities': self.enemies,
+            'obstacles': self.obs, 'entities': self.enemies,
             'coins': [c for c in self.coin_list if not c['collected']],
-            'ground': C.GROUND,
-            'score': self.score,
-            'coins_collected': self.coins,
-            'alive': self.alive
+            'ground': C.GROUND, 'score': self.score,
+            'coins_collected': self.coins, 'alive': self.alive
         }
 
 
@@ -260,8 +516,8 @@ class Agent:
             try:
                 self.model.load_state_dict(torch.load(C.MODEL, map_location=self.dev))
                 self.target.load_state_dict(self.model.state_dict())
-                logger.info("✅ Model loaded")
-            except Exception as e: logger.warning(f"⚠��� Load failed: {e}")
+                logger.info("✅ DQN loaded")
+            except Exception as e: logger.warning(f"⚠️ DQN load failed: {e}")
 
     def act(self, s):
         if random.random() <= self.eps: return random.randrange(C.ACTS)
@@ -299,37 +555,12 @@ class Agent:
     def save(self): torch.save(self.model.state_dict(), C.MODEL)
 
 
-# ============================================================================
-# CHAT MEMORY
-# ============================================================================
-
-class ChatMem:
-    def __init__(self):
-        self.data = {}
-        if os.path.exists(C.CHAT):
-            try:
-                with open(C.CHAT, 'r', encoding='utf-8') as f: self.data = json.load(f)
-            except: pass
-    def save(self):
-        with open(C.CHAT, 'w', encoding='utf-8') as f: json.dump(self.data, f, ensure_ascii=False, indent=2)
-    def add(self, q, a):
-        self.data[q.lower()] = a; self.save(); return f"✅ {q} → {a}"
-    def find(self, q):
-        q = q.lower()
-        if q in self.data: return self.data[q]
-        words = q.split(); best, bs = None, 0
-        for k, v in self.data.items():
-            sc = sum(1 for w in words if w in k)
-            if sc > bs: bs, best = sc, v
-        return best if bs >= len(words) * 0.4 else None
-
-
 # ============================================================================
 # GLOBAL STATE
 # ============================================================================
 
 agent = Agent()
-chat = ChatMem()
+chat = NeuralChat()
 seed = random.randint(0, 999999)
 ai_env = Engine(seed)
 pl_env = Engine(seed)
@@ -337,7 +568,7 @@ is_training = False
 
 
 # ============================================================================
-# RICH GRAPHICS HTML
+# HTML (Rich Graphics)
 # ============================================================================
 
 HTML = """
@@ -346,7 +577,7 @@ HTML = """
 <head>
 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
-<title>🧠 AI Platformer</title>
+<title>🧠 AI Platformer + Neural Chat</title>
 <style>
 *{margin:0;padding:0;box-sizing:border-box}
 body{background:#0d1117;color:#eee;font-family:'Segoe UI',sans-serif;display:flex;justify-content:center;padding:20px;min-height:100vh}
@@ -379,12 +610,13 @@ canvas{width:100%;aspect-ratio:4/1;border-radius:8px;display:block;image-renderi
 .cm .u{border-left:3px solid #ff6b6b}
 .cm .b{border-left:3px solid #4ecdc4}
 .hidden{display:none}
+.nn-info{font-size:0.85em;color:#888;margin-top:8px;padding:8px;background:#0d1117;border-radius:6px}
 </style>
 </head>
 <body>
 <div class="wrap">
 <h1>🧠 AI vs Player Platformer</h1>
-<p class="sub">🤖 Нейросеть слева 🎮 Ты справа (⬅️ ➡️ ⬆️)</p>
+<p class="sub">🤖 Нейросеть слева 🎮 Ты справа (⬅️ ➡️ ⬆️) | 💬 Чат = нейросеть с нуля</p>
 <div class="row">
 <div class="box"><h3>🤖 Нейросеть</h3><canvas id="ac"></canvas></div>
 <div class="box"><h3>🎮 Ты</h3><canvas id="pc"></canvas></div>
@@ -403,17 +635,22 @@ canvas{width:100%;aspect-ratio:4/1;border-radius:8px;display:block;image-renderi
 <button class="brs" id="bReset">🔄 Новый уровень</button>
 </div>
 <div class="tabs">
-<div class="tab active" data-tab="chat">💬 Чат</div>
-<div class="tab" data-tab="train">🧠 Тренировка</div>
+<div class="tab active" data-tab="chat">💬 Нейро-чат</div>
+<div class="tab" data-tab="train">🧠 Тренировка DQN</div>
 <div class="tab" data-tab="stats">📊 Статистика</div>
 </div>
 <div class="tc">
 <div id="chatTab">
-<div class="cm" id="msgs"><div class="b">🤖 Привет! Команды: /ai вопрос, /data вопрос|ответ, /stats, /train</div></div>
-<div class="ca"><input id="ci" placeholder="Введите команду..." onkeydown="if(event.key==='Enter')sendChat()"><button onclick="sendChat()">➤</button></div>
+<div class="cm" id="msgs">
+<div class="b">🧠 Привет! Я нейросетевой чат, написанный с нуля на PyTorch.</div>
+<div class="b">Команды: /data вопрос|ответ, /stats, /train</div>
+<div class="b">Спрашивай что угодно — я ищу по смыслу, не по словам!</div>
+</div>
+<div class="ca"><input id="ci" placeholder="Задай вопрос или /data вопрос|ответ..." onkeydown="if(event.key==='Enter')sendChat()"><button onclick="sendChat()">➤</button></div>
+<div class="nn-info" id="nnInfo">Загрузка модели...</div>
 </div>
 <div id="trainTab" class="hidden">
-<h3>🧠 Тренировка DQN</h3><p>DQN (256→256→128 нейронов)</p>
+<h3>🧠 Тренировка DQN</h3><p>Deep Q-Network (256→256→128)</p>
 <button onclick="startTrain()" style="padding:12px 35px;background:linear-gradient(135deg,#ff6b6b,#ee5a24);color:#fff;border:none;border-radius:10px;font-size:1.1em;cursor:pointer;margin-top:10px">🚀 Запустить</button>
 <div id="ts" style="margin-top:10px;color:#888">⏸ Остановлена</div>
 </div>
@@ -428,176 +665,57 @@ let pA=0;
 function draw(ctx,d,show){
     const W=ctx.canvas.width,H=ctx.canvas.height,cW=W/80,cH=H/20;
     ctx.clearRect(0,0,W,H);
-
-    // Sky gradient
     const sg=ctx.createLinearGradient(0,0,0,H);
     sg.addColorStop(0,'#0f0c29');sg.addColorStop(0.5,'#302b63');sg.addColorStop(1,'#24243e');
     ctx.fillStyle=sg;ctx.fillRect(0,0,W,H);
-
-    // Stars
     ctx.fillStyle='rgba(255,255,255,0.3)';
-    for(let i=0;i<30;i++){
-        const sx=(i*137+d.player[0]*0.1)%W,sy=(i*97)%((d.ground-2)*cH);
-        ctx.fillRect(sx,sy,2,2);
-    }
-
+    for(let i=0;i<30;i++){const sx=(i*137+d.player[0]*0.1)%W,sy=(i*97)%((d.ground-2)*cH);ctx.fillRect(sx,sy,2,2)}
     const cam=Math.max(0,d.player[0]-40);
     function toS(wx,wy){return[(wx-cam)*cW,wy*cH]}
-
-    // Ground layers
     const gy=d.ground*cH;
     const gg=ctx.createLinearGradient(0,gy,0,H);
     gg.addColorStop(0,'#4a7c59');gg.addColorStop(0.15,'#3d6b4e');gg.addColorStop(0.5,'#5c4033');gg.addColorStop(1,'#3e2723');
     ctx.fillStyle=gg;ctx.fillRect(0,gy,W,H-gy);
-    // Grass top
     ctx.fillStyle='#6abf69';ctx.fillRect(0,gy,W,cH*0.3);
-    ctx.fillStyle='#81c784';
-    for(let gx=0;gx<W;gx+=8){ctx.fillRect(gx,gy-cH*0.1,4,cH*0.15)}
-
-    // Obstacles with detail
+    ctx.fillStyle='#81c784';for(let gx=0;gx<W;gx+=8)ctx.fillRect(gx,gy-cH*0.1,4,cH*0.15);
     for(const o of d.obstacles){
         const[x,y]=toS(o.x,o.y);
-        if(o.pit){
-            const pg=ctx.createLinearGradient(0,y-cH,0,y+cH);
-            pg.addColorStop(0,'#1a1a2e');pg.addColorStop(1,'#000');
-            ctx.fillStyle=pg;ctx.fillRect(x,y-cH,o.w*cW,cH*2);
-            ctx.fillStyle='#ff4444';ctx.fillRect(x,y-cH*0.5,o.w*cW,2);
-        }else{
-            // Brick pattern
-            const bg=ctx.createLinearGradient(x,y,x,y+o.h*cH);
-            bg.addColorStop(0,'#8d6e63');bg.addColorStop(1,'#6d4c41');
-            ctx.fillStyle=bg;ctx.fillRect(x,y,o.w*cW,o.h*cH);
-            // Brick lines
-            ctx.strokeStyle='rgba(0,0,0,0.3)';ctx.lineWidth=1;
-            for(let by=0;by<o.h;by++){
-                const yy=y+by*cH;
-                ctx.beginPath();ctx.moveTo(x,yy);ctx.lineTo(x+o.w*cW,yy);ctx.stroke();
-                const off=(by%2)*cW*0.5;
-                for(let bx=off;bx<o.w*cW;bx+=cW){
-                    ctx.beginPath();ctx.moveTo(x+bx,yy);ctx.lineTo(x+bx,yy+cH);ctx.stroke();
-                }
-            }
-            // Top highlight
-            ctx.fillStyle='rgba(255,255,255,0.15)';ctx.fillRect(x,y,o.w*cW,cH*0.15);
-            // Shadow
-            ctx.fillStyle='rgba(0,0,0,0.3)';ctx.fillRect(x+o.w*cW,y,3,o.h*cH);
-        }
+        if(o.pit){const pg=ctx.createLinearGradient(0,y-cH,0,y+cH);pg.addColorStop(0,'#1a1a2e');pg.addColorStop(1,'#000');ctx.fillStyle=pg;ctx.fillRect(x,y-cH,o.w*cW,cH*2);ctx.fillStyle='#ff4444';ctx.fillRect(x,y-cH*0.5,o.w*cW,2)}
+        else{const bg=ctx.createLinearGradient(x,y,x,y+o.h*cH);bg.addColorStop(0,'#8d6e63');bg.addColorStop(1,'#6d4c41');ctx.fillStyle=bg;ctx.fillRect(x,y,o.w*cW,o.h*cH);ctx.strokeStyle='rgba(0,0,0,0.3)';ctx.lineWidth=1;for(let by=0;by<o.h;by++){const yy=y+by*cH;ctx.beginPath();ctx.moveTo(x,yy);ctx.lineTo(x+o.w*cW,yy);ctx.stroke();const off=(by%2)*cW*0.5;for(let bx=off;bx<o.w*cW;bx+=cW){ctx.beginPath();ctx.moveTo(x+bx,yy);ctx.lineTo(x+bx,yy+cH);ctx.stroke()}}ctx.fillStyle='rgba(255,255,255,0.15)';ctx.fillRect(x,y,o.w*cW,cH*0.15);ctx.fillStyle='rgba(0,0,0,0.3)';ctx.fillRect(x+o.w*cW,y,3,o.h*cH)}
     }
-
-    // Enemies with animation
     const t=Date.now()/200;
-    for(const e of d.entities){
-        const[x,y]=toS(e.x,e.y);
-        const bounce=Math.sin(t+e.x)*2;
-        ctx.save();ctx.translate(x+cW/2,y+cH/2+bounce);
-        // Body
-        const eg=ctx.createRadialGradient(0,0,2,0,0,cH/2);
-        eg.addColorStop(0,'#ff6b6b');eg.addColorStop(1,'#c0392b');
-        ctx.fillStyle=eg;ctx.beginPath();ctx.arc(0,0,cH/2.5,0,Math.PI*2);ctx.fill();
-        // Eyes
-        ctx.fillStyle='#fff';
-        ctx.beginPath();ctx.arc(-4,-3,3,0,Math.PI*2);ctx.arc(4,-3,3,0,Math.PI*2);ctx.fill();
-        ctx.fillStyle='#000';
-        const ex=e.dir*2;
-        ctx.beginPath();ctx.arc(-4+ex,-3,1.5,0,Math.PI*2);ctx.arc(4+ex,-3,1.5,0,Math.PI*2);ctx.fill();
-        // Glow
-        ctx.shadowColor='#ff6b6b';ctx.shadowBlur=10;
-        ctx.strokeStyle='#ff6b6b';ctx.lineWidth=1;ctx.beginPath();ctx.arc(0,0,cH/2.2,0,Math.PI*2);ctx.stroke();
-        ctx.restore();
-    }
-
-    // Coins with sparkle
-    for(const c of d.coins){
-        const[x,y]=toS(c.x,c.y);
-        const pulse=1+Math.sin(t*2+c.x)*0.15;
-        ctx.save();ctx.translate(x+cW/2,y+cH/2);ctx.scale(pulse,pulse);
-        const cg=ctx.createRadialGradient(-2,-2,1,0,0,cH/3);
-        cg.addColorStop(0,'#fff9c4');cg.addColorStop(0.5,'#ffd700');cg.addColorStop(1,'#f9a825');
-        ctx.fillStyle=cg;ctx.beginPath();ctx.arc(0,0,cH/3,0,Math.PI*2);ctx.fill();
-        ctx.shadowColor='#ffd700';ctx.shadowBlur=12;
-        ctx.strokeStyle='#ffeb3b';ctx.lineWidth=1.5;ctx.beginPath();ctx.arc(0,0,cH/3,0,Math.PI*2);ctx.stroke();
-        // Shine
-        ctx.fillStyle='rgba(255,255,255,0.8)';ctx.beginPath();ctx.arc(-3,-3,2,0,Math.PI*2);ctx.fill();
-        ctx.restore();
-    }
-
-    // Player
-    if(show&&d.alive){
-        const[px,py]=toS(d.player[0],d.player[1]);
-        ctx.save();
-        // Glow
-        ctx.shadowColor='#00ff88';ctx.shadowBlur=20;
-        // Body gradient
-        const pg=ctx.createLinearGradient(px,py,px+cW,py+cH);
-        pg.addColorStop(0,'#00ff88');pg.addColorStop(1,'#00b894');
-        ctx.fillStyle=pg;
-        ctx.fillRect(px+2,py+2,cW-4,cH-4);
-        // Face
-        ctx.shadowBlur=0;
-        ctx.fillStyle='#fff';
-        ctx.fillRect(px+cW*0.2,py+cH*0.25,cW*0.2,cH*0.2);
-        ctx.fillRect(px+cW*0.6,py+cH*0.25,cW*0.2,cH*0.2);
-        ctx.fillStyle='#0d1117';
-        ctx.fillRect(px+cW*0.25,py+cH*0.3,cW*0.1,cH*0.1);
-        ctx.fillRect(px+cW*0.65,py+cH*0.3,cW*0.1,cH*0.1);
-        ctx.restore();
-    }
+    for(const e of d.entities){const[x,y]=toS(e.x,e.y);const bounce=Math.sin(t+e.x)*2;ctx.save();ctx.translate(x+cW/2,y+cH/2+bounce);const eg=ctx.createRadialGradient(0,0,2,0,0,cH/2);eg.addColorStop(0,'#ff6b6b');eg.addColorStop(1,'#c0392b');ctx.fillStyle=eg;ctx.beginPath();ctx.arc(0,0,cH/2.5,0,Math.PI*2);ctx.fill();ctx.fillStyle='#fff';ctx.beginPath();ctx.arc(-4,-3,3,0,Math.PI*2);ctx.arc(4,-3,3,0,Math.PI*2);ctx.fill();ctx.fillStyle='#000';const ex=e.dir*2;ctx.beginPath();ctx.arc(-4+ex,-3,1.5,0,Math.PI*2);ctx.arc(4+ex,-3,1.5,0,Math.PI*2);ctx.fill();ctx.shadowColor='#ff6b6b';ctx.shadowBlur=10;ctx.strokeStyle='#ff6b6b';ctx.lineWidth=1;ctx.beginPath();ctx.arc(0,0,cH/2.2,0,Math.PI*2);ctx.stroke();ctx.restore()}
+    for(const c of d.coins){const[x,y]=toS(c.x,c.y);const pulse=1+Math.sin(t*2+c.x)*0.15;ctx.save();ctx.translate(x+cW/2,y+cH/2);ctx.scale(pulse,pulse);const cg=ctx.createRadialGradient(-2,-2,1,0,0,cH/3);cg.addColorStop(0,'#fff9c4');cg.addColorStop(0.5,'#ffd700');cg.addColorStop(1,'#f9a825');ctx.fillStyle=cg;ctx.beginPath();ctx.arc(0,0,cH/3,0,Math.PI*2);ctx.fill();ctx.shadowColor='#ffd700';ctx.shadowBlur=12;ctx.strokeStyle='#ffeb3b';ctx.lineWidth=1.5;ctx.beginPath();ctx.arc(0,0,cH/3,0,Math.PI*2);ctx.stroke();ctx.fillStyle='rgba(255,255,255,0.8)';ctx.beginPath();ctx.arc(-3,-3,2,0,Math.PI*2);ctx.fill();ctx.restore()}
+    if(show&&d.alive){const[px,py]=toS(d.player[0],d.player[1]);ctx.save();ctx.shadowColor='#00ff88';ctx.shadowBlur=20;const pg=ctx.createLinearGradient(px,py,px+cW,py+cH);pg.addColorStop(0,'#00ff88');pg.addColorStop(1,'#00b894');ctx.fillStyle=pg;ctx.fillRect(px+2,py+2,cW-4,cH-4);ctx.shadowBlur=0;ctx.fillStyle='#fff';ctx.fillRect(px+cW*0.2,py+cH*0.25,cW*0.2,cH*0.2);ctx.fillRect(px+cW*0.6,py+cH*0.25,cW*0.2,cH*0.2);ctx.fillStyle='#0d1117';ctx.fillRect(px+cW*0.25,py+cH*0.3,cW*0.1,cH*0.1);ctx.fillRect(px+cW*0.65,py+cH*0.3,cW*0.1,cH*0.1);ctx.restore()}
 }
 
 async function update(){
-    try{
-        const r=await fetch('/step',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({action:pA})});
-        const d=await r.json();
-        draw(aC,d.ai,true);draw(pC,d.player,d.player.alive);
-        document.getElementById('as').textContent=d.ai.score;
-        document.getElementById('ps').textContent=d.player.score;
-        document.getElementById('cc').textContent=d.player.coins_collected;
-        document.getElementById('ep').textContent=d.epsilon.toFixed(3);
-        document.getElementById('bs').textContent=d.best_score;
-    }catch(e){}
+    try{const r=await fetch('/step',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({action:pA})});const d=await r.json();draw(aC,d.ai,true);draw(pC,d.player,d.player.alive);document.getElementById('as').textContent=d.ai.score;document.getElementById('ps').textContent=d.player.score;document.getElementById('cc').textContent=d.player.coins_collected;document.getElementById('ep').textContent=d.epsilon.toFixed(3);document.getElementById('bs').textContent=d.best_score}catch(e){}
 }
-
 const sA=v=>{pA=v};
 document.getElementById('bL').onmousedown=()=>sA(1);document.getElementById('bL').onmouseup=()=>sA(0);
 document.getElementById('bR').onmousedown=()=>sA(2);document.getElementById('bR').onmouseup=()=>sA(0);
 document.getElementById('bJ').onmousedown=()=>sA(3);document.getElementById('bJ').onmouseup=()=>sA(0);
-document.addEventListener('keydown',e=>{
-    if(e.key==='ArrowLeft'){e.preventDefault();sA(1)}
-    else if(e.key==='ArrowRight'){e.preventDefault();sA(2)}
-    else if(e.key==='ArrowUp'||e.key===' '){e.preventDefault();sA(3)}
-});
+document.addEventListener('keydown',e=>{if(e.key==='ArrowLeft'){e.preventDefault();sA(1)}else if(e.key==='ArrowRight'){e.preventDefault();sA(2)}else if(e.key==='ArrowUp'||e.key===' '){e.preventDefault();sA(3)}});
 document.addEventListener('keyup',e=>{if(['ArrowLeft','ArrowRight','ArrowUp',' '].includes(e.key)){e.preventDefault();sA(0)}});
-
-document.getElementById('bReset').onclick=async()=>{
-    const r=await fetch('/reset',{method:'POST'});const d=await r.json();
-    draw(aC,d.ai,true);draw(pC,d.player,true);
-    document.getElementById('as').textContent=d.ai.score;
-    document.getElementById('ps').textContent=d.player.score;
-};
+document.getElementById('bReset').onclick=async()=>{const r=await fetch('/reset',{method:'POST'});const d=await r.json();draw(aC,d.ai,true);draw(pC,d.player,true);document.getElementById('as').textContent=d.ai.score;document.getElementById('ps').textContent=d.player.score};
 
 async function sendChat(){
     const inp=document.getElementById('ci');const msg=inp.value.trim();if(!msg)return;inp.value='';
-    const m=document.getElementById('msgs');
-    m.innerHTML+=`<div class="u">👤 ${msg}</div>`;m.scrollTop=m.scrollHeight;
+    const m=document.getElementById('msgs');m.innerHTML+=`<div class="u">👤 ${msg}</div>`;m.scrollTop=m.scrollHeight;
     const r=await fetch('/chat',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({message:msg})});
-    const d=await r.json();
-    m.innerHTML+=`<div class="b">🤖 ${d.response}</div>`;m.scrollTop=m.scrollHeight;
-}
-
-async function startTrain(){
-    document.getElementById('ts').textContent='⏳ Запуск...';
-    const r=await fetch('/train',{method:'POST'});const d=await r.json();
-    document.getElementById('ts').textContent=d.message;
+    const d=await r.json();m.innerHTML+=`<div class="b">🧠 ${d.response}</div>`;m.scrollTop=m.scrollHeight;
 }
-
+async function startTrain(){document.getElementById('ts').textContent='⏳ Запуск...';const r=await fetch('/train',{method:'POST'});const d=await r.json();document.getElementById('ts').textContent=d.message}
 document.querySelectorAll('.tab').forEach(t=>t.onclick=function(){
-    document.querySelectorAll('.tab').forEach(x=>x.classList.remove('active'));
-    this.classList.add('active');const n=this.dataset.tab;
-    document.querySelectorAll('.tc>div').forEach(d=>d.classList.add('hidden'));
-    document.getElementById(n+'Tab').classList.remove('hidden');
-    if(n==='stats')fetch('/stats').then(r=>r.json()).then(d=>{
-        document.getElementById('sc').innerHTML=`<p>🧠 Память: ${d.memory_size}</p><p>🎮 Шагов: ${d.steps}</p><p>📉 ε: ${d.epsilon}</p><p>🏆 Рекорд: ${d.best_score}</p><p>⚡ Тренируется: ${d.training?'✅':'❌'}</p>`;
-    });
+    document.querySelectorAll('.tab').forEach(x=>x.classList.remove('active'));this.classList.add('active');const n=this.dataset.tab;
+    document.querySelectorAll('.tc>div').forEach(d=>d.classList.add('hidden'));document.getElementById(n+'Tab').classList.remove('hidden');
+    if(n==='stats')fetch('/stats').then(r=>r.json()).then(d=>{document.getElementById('sc').innerHTML=`<p>🧠 DQN шагов: ${d.steps}</p><p>📉 ε: ${d.epsilon}</p><p>🏆 Рекорд: ${d.best_score}</p><p>⚡ Тренируется: ${d.training?'✅':'❌'}</p><hr style="border-color:#30363d;margin:8px 0"><p>💬 Чат записей: ${d.chat.entries}</p><p>📝 Словарь: ${d.chat.vocab}</p><p>🔢 Параметров чата: ${d.chat.params.toLocaleString()}</p><p>📐 Эмбеддинг: ${d.chat.emb_dim}D</p>`});
+});
+
+// Load NN info
+fetch('/stats').then(r=>r.json()).then(d=>{
+    document.getElementById('nnInfo').textContent=`🧠 Чат-нейросеть: ${d.chat.params.toLocaleString()} параметров | Словарь: ${d.chat.vocab} | Эмбеддинг: ${d.chat.emb_dim}D | Записей: ${d.chat.entries}`;
 });
 
 setInterval(update,100);update();
@@ -619,18 +737,11 @@ def index(): return render_template_string(HTML)
 def step():
     global ai_env, pl_env
     action = request.json.get('action', 0)
-    if ai_env.alive:
-        ai_env.step(agent.act(ai_env.get_state()))
-    else:
-        ai_env.reset()
-    if pl_env.alive:
-        pl_env.step(action)
-    else:
-        pl_env.reset()
-    return jsonify({
-        'ai': ai_env.world_data(), 'player': pl_env.world_data(),
-        'epsilon': agent.eps, 'best_score': agent.best
-    })
+    if ai_env.alive: ai_env.step(agent.act(ai_env.get_state()))
+    else: ai_env.reset()
+    if pl_env.alive: pl_env.step(action)
+    else: pl_env.reset()
+    return jsonify({'ai': ai_env.world_data(), 'player': pl_env.world_data(), 'epsilon': agent.eps, 'best_score': agent.best})
 
 @app.route('/reset', methods=['POST'])
 def reset():
@@ -642,18 +753,17 @@ def reset():
 @app.route('/chat', methods=['POST'])
 def chat_route():
     msg = request.json.get('message', '').strip()
-    if msg.startswith('/ai '):
-        a = chat.find(msg[4:])
-        return jsonify({'response': a or "🤖 Не знаю. Обучи через /data"})
-    elif msg.startswith('/data '):
+    if msg.startswith('/data '):
         p = msg[6:].split('|')
         if len(p) != 2: return jsonify({'response': "❌ Формат: /data вопрос|ответ"})
-        return jsonify({'response': chat.add(p[0].strip(), p[1].strip())})
+        return jsonify({'response': chat.teach(p[0], p[1])})
     elif msg == '/stats':
-        return jsonify({'response': f"📊 Память: {len(chat.data)}, Шагов: {agent.steps}"})
+        s = chat.stats
+        return jsonify({'response': f"🧠 Чат: {s['params']} парам., {s['vocab']} слов, {s['entries']} записей, {s['emb_dim']}D эмбеддинг"})
     elif msg == '/train':
         return jsonify({'response': start_training()})
-    return jsonify({'response': "🤖 Команды: /ai, /data, /stats, /train"})
+    else:
+        return jsonify({'response': chat.ask(msg)})
 
 @app.route('/train', methods=['POST'])
 def train_route(): return jsonify({'message': start_training()})
@@ -661,8 +771,9 @@ def train_route(): return jsonify({'message': start_training()})
 @app.route('/stats')
 def stats():
     return jsonify({
-        'memory_size': len(chat.data), 'steps': agent.steps,
-        'epsilon': round(agent.eps, 3), 'best_score': agent.best, 'training': is_training
+        'steps': agent.steps, 'epsilon': round(agent.eps, 3),
+        'best_score': agent.best, 'training': is_training,
+        'chat': chat.stats
     })
 
 def start_training():
@@ -675,11 +786,11 @@ def start_training():
             for ep in range(100):
                 if not is_training: break
                 sc = agent.train_ep()
-                if ep % 10 == 0: logger.info(f"Ep {ep}: score={sc:.1f}, ε={agent.eps:.3f}")
-        except Exception as e: logger.error(f"Train error: {e}")
+                if ep % 10 == 0: logger.info(f"DQN Ep {ep}: score={sc:.1f}, ε={agent.eps:.3f}")
+        except Exception as e: logger.error(f"DQN error: {e}")
         finally: is_training = False
     threading.Thread(target=_t, daemon=True).start()
-    return "🚀 Тренировка запущена!"
+    return "🚀 Тренировка DQN запущена!"
 
 if __name__ == '__main__':
     app.run(host='0.0.0.0', port=C.PORT, debug=False)