| """ |
| AI PLATFORMER + NEURAL CHATBOT (FROM SCRATCH) |
| Fixed jump physics, larger player, AABB collision, rich graphics |
| Custom PyTorch NLP model - no external NLP libraries |
| """ |
|
|
| import os, json, random, threading, logging, time, re, math |
| from collections import deque, Counter |
| from dataclasses import dataclass |
| from typing import Dict, List, Optional, Tuple |
| import numpy as np |
| import torch |
| import torch.nn as nn |
| import torch.optim as optim |
| from flask import Flask, jsonify, request, render_template_string |
|
|
| logging.basicConfig(level=logging.INFO, format='%(asctime)s [%(levelname)s] %(message)s') |
| logger = logging.getLogger(__name__) |
|
|
|
|
| @dataclass |
| class Cfg: |
| W: int = 80; H: int = 20; GROUND: int = 17; CHUNK: int = 30 |
| SAFE: int = 15; VIEW: int = 40 |
| GRAV: float = 0.45 |
| JUMP: float = -3.8 |
| SPEED: float = 0.35 |
| STATE: int = 40 * 40; ACTS: int = 4; MEM: int = 10000 |
| 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" |
| 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() |
|
|
|
|
| |
| |
| |
|
|
| class Tokenizer: |
| 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() |
| 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] |
| ids += [0] * (max_len - len(ids)) |
| return ids |
|
|
| @property |
| def vocab_size(self) -> int: |
| return len(self.word2idx) |
|
|
|
|
| |
| |
| |
|
|
| class ChatEncoder(nn.Module): |
| 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): |
| emb = self.embedding(x) |
| mask = (x != 0).unsqueeze(-1).float() |
| pooled = (emb * mask).sum(dim=1) / mask.sum(dim=1).clamp(min=1) |
| 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) |
| return nn.functional.normalize(out, p=2, dim=-1) |
|
|
|
|
| class NeuralChat: |
| 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): |
| self.questions = list(self.data.keys()) |
| if not self.questions: |
| return |
| 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() |
|
|
| def _train_model(self): |
| if len(self.questions) < 2: |
| logger.warning("⚠️ Too few entries to train") |
| return |
| optimizer = optim.Adam(self.model.parameters(), lr=C.CHAT_LR) |
| 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 |
| indices = list(range(n)); random.shuffle(indices) |
| for i in indices: |
| anchor = q_ids[i:i+1] |
| positive = q_ids[i:i+1] |
| 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) |
| emb_p = self.model(positive) |
| emb_n = self.model(negative) |
| pos_sim = nn.functional.cosine_similarity(emb_a, emb_p) |
| neg_sim = nn.functional.cosine_similarity(emb_a, emb_n) |
| loss = torch.relu(0.3 - 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): |
| 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) |
| self.model.train() |
|
|
| def ask(self, query: str) -> str: |
| 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) |
| 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: |
| return f"{self.data[self.questions[best_idx]]} (🧠 {int(best_score*100)}%)" |
| return f"🤖 Не знаю «{query}». Научи: /data {query}|ответ" |
|
|
| def teach(self, question: str, answer: str) -> str: |
| 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() |
| 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} |
|
|
|
|
| |
| |
| |
|
|
| class Engine: |
| PW = 0.8 |
| PH = 0.95 |
|
|
| def __init__(self, seed=None): |
| self.seed = seed or random.randint(0, 999999) |
| self.reset() |
|
|
| def reset(self): |
| self.px, self.py = 5.0, float(C.GROUND) |
| self.vx, self.vy = 0.0, 0.0 |
| self.grounded = True; self.alive = True |
| self.score = 0; self.coins = 0; self.step_n = 0 |
| self.chunks: Dict[int, dict] = {} |
| self.obs: List[dict] = []; self.enemies: List[dict] = []; self.coin_list: List[dict] = [] |
| self._load_chunks() |
| return self.get_state() |
|
|
| def _gen_chunk(self, cid: int) -> dict: |
| rng = random.Random((cid * 1337 + self.seed) % 999999) |
| bx = cid * C.CHUNK; obs, ens, cns = [], [], [] |
| diff = max(1.0, abs(cid) * 0.1); safe = bx < C.SAFE |
| if not safe: |
| for _ in range(rng.randint(3, 6) + int(diff)): |
| x = bx + rng.randint(5, 25); h = rng.randint(1, 3 + int(diff * 0.5)); w = rng.randint(1, 3) |
| obs.append({'x': x, 'y': C.GROUND - h, 'w': w, 'h': h, 'pit': False}) |
| for _ in range(rng.randint(1, 2)): |
| x = bx + rng.randint(10, 20) |
| obs.append({'x': x, 'y': C.GROUND + 1, 'w': rng.randint(2, 4), 'h': 1, 'pit': True}) |
| for _ in range(rng.randint(1, 2)): |
| x = bx + rng.randint(10, 20) |
| ens.append({'x': x, 'y': C.GROUND - 1, 'type': rng.choice(['walker', 'jumper']), |
| 'dir': rng.choice([-1, 1]), 'spd': 0.3 + rng.random() * 0.3, |
| 'rng': rng.randint(3, 8), 'ox': x}) |
| 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}) |
| return {'obs': obs, 'ens': ens, 'cns': cns} |
|
|
| def _load_chunks(self): |
| cc = int(self.px // C.CHUNK) |
| 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): |
| ch = self.chunks.get(i, {}) |
| self.obs.extend([o for o in ch.get('obs', []) if vl <= o['x'] <= vr]) |
| self.enemies.extend([e for e in ch.get('ens', []) if vl <= e['x'] <= vr]) |
| self.coin_list.extend([c for c in ch.get('cns', []) if not c['collected'] and vl <= c['x'] <= vr]) |
|
|
| def _aabb(self, ax, ay, aw, ah, bx, by, bw, bh): |
| return ax < bx + bw and ax + aw > bx and ay < by + bh and ay + ah > by |
|
|
| def get_state(self): |
| s = np.zeros((C.VIEW, C.VIEW), dtype=np.float32); h = C.VIEW // 2 |
| px, py = int(round(self.px)), int(round(self.py)); s[h, h] = 1.0 |
| for o in self.obs: |
| dx, dy = int(round(o['x'])) - px, int(round(o['y'])) - py |
| v = -1.0 if o.get('pit') else 0.8 |
| 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 |
| 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 |
| 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 |
| return s.flatten() |
|
|
| def step(self, action: int): |
| sound = None |
| |
| 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.px += self.vx |
| for o in self.obs: |
| if o.get('pit'): continue |
| if self._aabb(self.px, self.py, self.PW, self.PH, o['x'], o['y'], o['w'], o['h']): |
| if self.vx > 0: self.px = o['x'] - self.PW |
| elif self.vx < 0: self.px = o['x'] + o['w'] |
| self.vx = 0 |
|
|
| |
| 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 |
| for o in self.obs: |
| if o.get('pit'): continue |
| if self._aabb(self.px, self.py, self.PW, self.PH, o['x'], o['y'], o['w'], o['h']): |
| if self.vy > 0: |
| self.py = o['y'] - self.PH; self.vy = 0.0; self.grounded = True |
| elif self.vy < 0: |
| self.py = o['y'] + o['h']; self.vy = 0.0 |
|
|
| |
| 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 + self.PW / 2 <= o['x'] + o['w'] and self.py >= C.GROUND: |
| self.alive = False; return self.get_state(), -50.0, True, 'die' |
| for e in self.enemies: |
| if self._aabb(self.px, self.py, self.PW, self.PH, e['x'] - 0.3, e['y'] - 0.3, 0.6, 0.6): |
| self.alive = False; return self.get_state(), -50.0, True, 'die' |
|
|
| |
| got = 0 |
| for c in self.coin_list: |
| if not c['collected'] and self._aabb(self.px, self.py, self.PW, self.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' |
|
|
| |
| t = time.time() |
| for e in self.enemies: |
| if e['type'] == 'walker': |
| e['x'] += e['spd'] * e['dir'] |
| if abs(e['x'] - e['ox']) > e['rng']: e['dir'] *= -1 |
| else: |
| e['y'] = (C.GROUND - 1) + np.sin(t * e['spd'] * 3) * 0.5 |
|
|
| self.score += 1; self.step_n += 1; self._load_chunks() |
| done = self.step_n > 3000 |
| 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, |
| '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 |
| } |
|
|
|
|
| |
| |
| |
|
|
| class Net(nn.Module): |
| def __init__(self): |
| super().__init__() |
| self.net = nn.Sequential( |
| nn.Linear(C.STATE, 256), nn.ReLU(), |
| nn.Linear(256, 256), nn.ReLU(), |
| nn.Linear(256, 128), nn.ReLU(), |
| nn.Linear(128, C.ACTS) |
| ) |
| def forward(self, x): return self.net(x) |
|
|
| class Agent: |
| def __init__(self): |
| self.dev = torch.device('cuda' if torch.cuda.is_available() else 'cpu') |
| self.model = Net().to(self.dev) |
| self.target = Net().to(self.dev) |
| self.target.load_state_dict(self.model.state_dict()) |
| self.opt = optim.Adam(self.model.parameters(), lr=C.LR) |
| self.crit = nn.MSELoss() |
| self.mem = deque(maxlen=C.MEM) |
| self.eps = 1.0; self.steps = 0; self.best = 0; self.training = False |
| if os.path.exists(C.MODEL): |
| 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("✅ 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) |
| with torch.no_grad(): |
| return torch.argmax(self.model(torch.FloatTensor(s).unsqueeze(0).to(self.dev))).item() |
|
|
| def remember(self, s, a, r, ns, d): self.mem.append((s, a, r, ns, d)) |
|
|
| def replay(self): |
| if len(self.mem) < C.BATCH: return |
| b = random.sample(self.mem, C.BATCH) |
| st = torch.FloatTensor([x[0] for x in b]).to(self.dev) |
| ac = torch.LongTensor([x[1] for x in b]).to(self.dev) |
| rw = torch.FloatTensor([x[2] for x in b]).to(self.dev) |
| ns = torch.FloatTensor([x[3] for x in b]).to(self.dev) |
| dn = torch.FloatTensor([x[4] for x in b]).to(self.dev) |
| q = self.model(st).gather(1, ac.unsqueeze(1)).squeeze() |
| nq = self.target(ns).max(1)[0].detach() |
| tgt = rw + C.GAMMA * nq * (1 - dn) |
| loss = self.crit(q, tgt) |
| self.opt.zero_grad(); loss.backward(); self.opt.step() |
| if self.eps > 0.01: self.eps *= C.EPS_DEC |
| self.steps += 1 |
| if self.steps % 100 == 0: self.target.load_state_dict(self.model.state_dict()) |
|
|
| def train_ep(self): |
| env = Engine(); s = env.reset(); tr = 0.0; d = False; n = 0 |
| while not d and n < 500: |
| a = self.act(s); ns, r, d, _ = env.step(a) |
| self.remember(s, a, r, ns, d); self.replay() |
| s = ns; tr += r; n += 1 |
| if tr > self.best: self.best = tr; self.save() |
| return tr |
|
|
| def save(self): torch.save(self.model.state_dict(), C.MODEL) |
|
|
|
|
| |
| |
| |
|
|
| agent = Agent() |
| chat = NeuralChat() |
| seed = random.randint(0, 999999) |
| ai_env = Engine(seed) |
| pl_env = Engine(seed) |
| is_training = False |
|
|
|
|
| |
| |
| |
|
|
| HTML = """ |
| <!DOCTYPE html> |
| <html lang="ru"> |
| <head> |
| <meta charset="UTF-8"> |
| <meta name="viewport" content="width=device-width, initial-scale=1.0"> |
| <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} |
| .wrap{max-width:1100px;width:100%} |
| h1{text-align:center;padding:15px 0;background:linear-gradient(135deg,#ff6b6b,#4ecdc4);-webkit-background-clip:text;-webkit-text-fill-color:transparent;font-size:2.2em} |
| .sub{text-align:center;color:#888;margin-bottom:15px} |
| .row{display:flex;gap:20px;flex-wrap:wrap} |
| .box{flex:1;min-width:320px;background:#161b22;border-radius:16px;padding:15px;box-shadow:0 8px 32px rgba(0,0,0,.5);border:1px solid #30363d} |
| .box h3{text-align:center;margin-bottom:10px;color:#c9d1d9} |
| canvas{width:100%;aspect-ratio:4/1;border-radius:8px;display:block;image-rendering:pixelated;background:#0d1117} |
| .ctrl{display:flex;justify-content:center;gap:12px;margin:15px 0;flex-wrap:wrap} |
| .ctrl button{padding:12px 30px;font-size:1.1em;border:none;border-radius:10px;cursor:pointer;font-weight:bold;transition:all .15s;color:#fff;text-shadow:0 1px 2px rgba(0,0,0,.5)} |
| .ctrl button:hover{transform:scale(1.05);filter:brightness(1.2)} |
| .ctrl button:active{transform:scale(.93)} |
| .bl,.br{background:linear-gradient(135deg,#ff6b6b,#ee5a24)} |
| .bj{background:linear-gradient(135deg,#4ecdc4,#2ecc71);padding:12px 45px} |
| .brs{background:linear-gradient(135deg,#a29bfe,#6c5ce7)} |
| .stats{background:#161b22;border-radius:12px;padding:12px 20px;margin:10px 0;display:flex;justify-content:space-around;flex-wrap:wrap;gap:10px;font-size:1.1em;border:1px solid #30363d} |
| .stats span{color:#ff6b6b;font-weight:bold} |
| .tabs{display:flex;gap:10px;margin:15px 0;flex-wrap:wrap} |
| .tab{padding:10px 22px;background:#161b22;border-radius:10px;cursor:pointer;border:2px solid #30363d;transition:all .3s;color:#c9d1d9} |
| .tab:hover{border-color:#ff6b6b} |
| .tab.active{border-color:#ff6b6b;background:#1c2333} |
| .tc{background:#161b22;border-radius:12px;padding:20px;min-height:200px;border:1px solid #30363d} |
| .ca{display:flex;gap:10px;margin-top:10px} |
| .ca input{flex:1;padding:10px;border-radius:8px;border:1px solid #30363d;background:#0d1117;color:#eee;font-size:1em} |
| .ca button{padding:10px 25px;background:#ff6b6b;color:#fff;border:none;border-radius:8px;cursor:pointer;font-weight:bold} |
| .cm{max-height:200px;overflow-y:auto;padding:5px} |
| .cm div{padding:6px 12px;margin:3px 0;border-radius:6px;background:#0d1117} |
| .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> |
| <div class="row"> |
| <div class="box"><h3>🤖 Нейросеть</h3><canvas id="ac"></canvas></div> |
| <div class="box"><h3>🎮 Ты</h3><canvas id="pc"></canvas></div> |
| </div> |
| <div class="stats"> |
| <div>🤖 ИИ: <span id="as">0</span></div> |
| <div>🎮 Ты: <span id="ps">0</span></div> |
| <div>🪙 Монет: <span id="cc">0</span></div> |
| <div>🧠 ε: <span id="ep">1.00</span></div> |
| <div>🏆 Рекорд: <span id="bs">0</span></div> |
| </div> |
| <div class="ctrl"> |
| <button class="bl" id="bL">⬅️ Влево</button> |
| <button class="bj" id="bJ">⬆️ ПРЫЖОК</button> |
| <button class="br" id="bR">➡️ Вправо</button> |
| <button class="brs" id="bReset">🔄 Новый уровень</button> |
| </div> |
| <div class="tabs"> |
| <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">🧠 Привет! Я нейросетевой чат, написанный с нуля на 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>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> |
| <div id="statsTab" class="hidden"><h3>📊 Статистика</h3><div id="sc">Загрузка...</div></div> |
| </div> |
| </div> |
| <script> |
| function initC(id){const c=document.getElementById(id);c.width=800;c.height=200;return c.getContext('2d')} |
| const aC=initC('ac'),pC=initC('pc'); |
| 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 |
| 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)} |
| |
| const cam=Math.max(0,d.player[0]-40); |
| function toS(wx,wy){return[(wx-cam)*cW,wy*cH]} |
| |
| // Ground |
| 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); |
| 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 |
| 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{ |
| 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 |
| 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); |
| 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(); |
| } |
| |
| // Coins |
| 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(); |
| } |
| |
| // PLAYER — FIXED: larger, more visible |
| if(show&&d.alive){ |
| const[px,py]=toS(d.player[0],d.player[1]); |
| const pw=cW*0.85, ph=cH*0.95; |
| const ox=px+(cW-pw)/2, oy=py+(cH-ph)/2; |
| ctx.save(); |
| ctx.shadowColor='#00ff88';ctx.shadowBlur=25; |
| const pg=ctx.createLinearGradient(ox,oy,ox+pw,oy+ph); |
| pg.addColorStop(0,'#00ff88');pg.addColorStop(0.5,'#00e676');pg.addColorStop(1,'#00b894'); |
| ctx.fillStyle=pg;ctx.fillRect(ox,oy,pw,ph); |
| ctx.shadowBlur=0; |
| ctx.strokeStyle='#b9f6ca';ctx.lineWidth=2;ctx.strokeRect(ox,oy,pw,ph); |
| // Eyes |
| ctx.fillStyle='#fff'; |
| ctx.fillRect(ox+pw*0.15,oy+ph*0.2,pw*0.25,ph*0.22); |
| ctx.fillRect(ox+pw*0.6,oy+ph*0.2,pw*0.25,ph*0.22); |
| ctx.fillStyle='#0d1117'; |
| ctx.fillRect(ox+pw*0.22,oy+ph*0.27,pw*0.12,ph*0.1); |
| ctx.fillRect(ox+pw*0.67,oy+ph*0.27,pw*0.12,ph*0.1); |
| // Mouth |
| ctx.fillStyle='#0d1117'; |
| ctx.fillRect(ox+pw*0.3,oy+ph*0.6,pw*0.4,ph*0.08); |
| 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){} |
| } |
| |
| 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('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; |
| }; |
| |
| 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 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; |
| } |
| |
| 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>🧠 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>`; |
| }); |
| }); |
| |
| 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(); |
| </script> |
| </body> |
| </html> |
| """ |
|
|
|
|
| |
| |
| |
|
|
| app = Flask(__name__) |
|
|
| @app.route('/') |
| def index(): return render_template_string(HTML) |
|
|
| @app.route('/step', methods=['POST']) |
| 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 |
| }) |
|
|
| @app.route('/reset', methods=['POST']) |
| def reset(): |
| global seed, ai_env, pl_env |
| seed = random.randint(0, 999999) |
| ai_env = Engine(seed); pl_env = Engine(seed) |
| return jsonify({'ai': ai_env.world_data(), 'player': pl_env.world_data()}) |
|
|
| @app.route('/chat', methods=['POST']) |
| def chat_route(): |
| msg = request.json.get('message', '').strip() |
| if msg.startswith('/data '): |
| p = msg[6:].split('|') |
| if len(p) != 2: return jsonify({'response': "❌ Формат: /data вопрос|ответ"}) |
| return jsonify({'response': chat.teach(p[0], p[1])}) |
| elif msg == '/stats': |
| 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()}) |
| else: |
| return jsonify({'response': chat.ask(msg)}) |
|
|
| @app.route('/train', methods=['POST']) |
| def train_route(): return jsonify({'message': start_training()}) |
|
|
| @app.route('/stats') |
| def stats(): |
| return jsonify({ |
| 'steps': agent.steps, 'epsilon': round(agent.eps, 3), |
| 'best_score': agent.best, 'training': is_training, |
| 'chat': chat.stats |
| }) |
|
|
| def start_training(): |
| global is_training |
| if is_training: return "⏳ Уже тренируется!" |
| is_training = True |
| def _t(): |
| global is_training |
| try: |
| for ep in range(100): |
| if not is_training: break |
| sc = agent.train_ep() |
| 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 "🚀 Тренировка DQN запущена!" |
|
|
|
|
| if __name__ == '__main__': |
| app.run(host='0.0.0.0', port=C.PORT, debug=False) |
