Update app.py

app.py

@@ -1,14 +1,596 @@
-import gradio as gr
-import spaces
 import torch
+import torch.nn as nn
+import torch.optim as optim
+import random
+import os
+import re
+import gradio as gr
+from datetime import datetime
+import math
+import numpy as np
+
+# ============ НАСТРОЙКИ ПУТЕЙ ============
+DATA_DIR = '/data'
+os.makedirs(DATA_DIR, exist_ok=True)
+MODEL_PATH = os.path.join(DATA_DIR, 'pytorch_model_andrey_v6.bin')
+
+DEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+# ============ СЛОВАРЬ ============
+WORDS = [
+    'привет', 'здравствуй', 'добрый', 'день', 'утро', 'вечер', 'ночь',
+    'как', 'дела', 'ты', 'поживаешь', 'жизнь', 'нормально', 'хорошо', 'отлично',
+    'плохо', 'грустно', 'весело', 'классно', 'супер', 'круто',
+    'что', 'кто', 'где', 'когда', 'почему', 'зачем', 'какой', 'сколько',
+    'нового', 'интересного', 'расскажи', 'покажи', 'объясни', 'помоги', 'скажи',
+    'я', 'меня', 'мне', 'мой', 'моя', 'моё', 'твой', 'твоя', 'твоё',
+    'люблю', 'нравится', 'хочу', 'могу', 'буду', 'делаю', 'работаю', 'учусь', 'отдыхаю',
+    'спасибо', 'пожалуйста', 'извини', 'прости', 'ладно', 'окей', 'конечно',
+    'пока', 'до', 'свидания', 'прощай', 'увидимся', 'завтра',
+    'да', 'нет', 'возможно', 'наверное', 'точно', 'вряд', 'ли',
+    'думаю', 'знаю', 'понимаю', 'чувствую',
+    'бот', 'андрей', 'помощник', 'робот', 'ии', 'нейросеть', 'умный',
+    'плюс', 'минус', 'умножить', 'делить', 'разделить', 'равно',
+    'один', 'два', 'три', 'четыре', 'пять', 'шесть', 'семь', 'восемь', 'девять', 'десять', 'ноль',
+    'одиннадцать', 'двенадцать', 'первый', 'второй', 'третий',
+    'создатель', 'евгений', 'openrussianai', 'компания', 'друг', 'имя', 'зовут',
+    'россия', 'москва', 'тверь', 'hugging', 'face', 'платформа', 'дом', 'живу',
+    'будет', 'посчитать', 'пример', 'решить',
+    'работа', 'отдых', 'путешествие', 'еда', 'вода', 'спорт', 'люди', 'мир', 'знание',
+    'будущее', 'прошлое', 'настоящее', 'интерес', 'радость', 'успех', 'дружба', 'любовь',
+    'семья', 'здоровье', 'счастье', 'удача', 'смех', 'солнце', 'звезды', 'мечта',
+    # Добавляем маркеры ролей для памяти
+    'пользователь', 'андрей', 'говорит' 
+]
+
+word_to_idx = {w: i+3 for i, w in enumerate(WORDS)}
+idx_to_word = {i+3: w for i, w in enumerate(WORDS)}
+idx_to_word[0] = '[PAD]'
+idx_to_word[1] = '[UNK]'
+idx_to_word[2] = '[START]'
+
+vocab_size = len(WORDS) + 3
+PAD = 0
+UNK = 1
+START = 2
+MAX_LEN = 30  # Увеличиваем длину, чтобы влезала история
+
+def tokenize(text):
+    return [word_to_idx.get(w, UNK) for w in text.lower().split()]
+
+def detokenize(tokens):
+    words = []
+    for t in tokens:
+        if t == START:
+            continue
+        if t == PAD:
+            break
+        if t == UNK:
+            continue 
+        w = idx_to_word.get(t)
+        if w:
+            words.append(w)
+    return ' '.join(words)
+
+def pad_sequence(seq, max_len=MAX_LEN):
+    if len(seq) >= max_len:
+        return seq[:max_len]
+    return seq + [PAD] * (max_len - len(seq))
+
+# ============ TRANSFORMER АРХИТЕКТУРА ============
+
+class PositionalEncoding(nn.Module):
+    def __init__(self, d_model, dropout=0.1, max_len=5000):
+        super(PositionalEncoding, self).__init__()
+        self.dropout = nn.Dropout(p=dropout)
+        
+        pe = torch.zeros(max_len, d_model)
+        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model))
+        
+        pe[:, 0::2] = torch.sin(position * div_term)
+        pe[:, 1::2] = torch.cos(position * div_term)
+        pe = pe.unsqueeze(0)
+        self.register_buffer('pe', pe)
+        
+    def forward(self, x):
+        x = x + self.pe[:, :x.size(1), :]
+        return self.dropout(x)
+
+class AndreyTransformer(nn.Module):
+    def __init__(self, vocab_size=vocab_size, d_model=128, nhead=4, 
+                 num_encoder_layers=2, num_decoder_layers=2, 
+                 dim_feedforward=256, dropout=0.1, max_len=MAX_LEN):
+        super().__init__()
+        
+        self.d_model = d_model
+        self.vocab_size = vocab_size
+        
+        self.embedding = nn.Embedding(vocab_size, d_model)
+        self.pos_encoder = PositionalEncoding(d_model, dropout, max_len)
+        self.pos_decoder = PositionalEncoding(d_model, dropout, max_len)
+        
+        self.transformer = nn.Transformer(
+            d_model=d_model,
+            nhead=nhead,
+            num_encoder_layers=num_encoder_layers,
+            num_decoder_layers=num_decoder_layers,
+            dim_feedforward=dim_feedforward,
+            dropout=dropout,
+            batch_first=True
+        )
+        
+        self.fc_out = nn.Linear(d_model, vocab_size)
+        self._init_weights()
+        
+    def _init_weights(self):
+        initrange = 0.1
+        self.embedding.weight.data.uniform_(-initrange, initrange)
+        self.fc_out.bias.data.zero_()
+        self.fc_out.weight.data.uniform_(-initrange, initrange)
+        
+    def generate_mask(self, tgt_len):
+        mask = torch.triu(torch.ones(tgt_len, tgt_len), diagonal=1).bool()
+        return mask.to(DEVICE)
+    
+    def create_pad_mask(self, seq, pad_idx=PAD):
+        return (seq == pad_idx).to(DEVICE)
+        
+    def forward(self, src, tgt, src_mask=None, tgt_mask=None, 
+                src_key_padding_mask=None, tgt_key_padding_mask=None):
+        src_emb = self.pos_encoder(self.embedding(src) * math.sqrt(self.d_model))
+        tgt_emb = self.pos_decoder(self.embedding(tgt) * math.sqrt(self.d_model))
+        
+        output = self.transformer(
+            src_emb, tgt_emb,
+            src_mask=src_mask,
+            tgt_mask=tgt_mask,
+            src_key_padding_mask=src_key_padding_mask,
+            tgt_key_padding_mask=tgt_key_padding_mask
+        )
+        
+        output = self.fc_out(output)
+        return output
+    
+    def encode(self, src):
+        src_emb = self.pos_encoder(self.embedding(src) * math.sqrt(self.d_model))
+        src_key_padding_mask = self.create_pad_mask(src)
+        memory = self.transformer.encoder(src_emb, src_key_padding_mask=src_key_padding_mask)
+        return memory
+    
+    def decode_step(self, tgt, memory, tgt_mask=None, tgt_key_padding_mask=None):
+        tgt_emb = self.pos_decoder(self.embedding(tgt) * math.sqrt(self.d_model))
+        
+        output = self.transformer.decoder(
+            tgt_emb, memory,
+            tgt_mask=tgt_mask,
+            tgt_key_padding_mask=tgt_key_padding_mask
+        )
+        
+        return self.fc_out(output)
+
+# ============ ДИАЛОГИ ДЛЯ ОБУЧЕНИЯ ============
+DIALOGUES = [
+    ("привет", "привет как дела"), ("здравствуй", "здравствуй рад тебя видеть"),
+    ("доброе утро", "доброе утро хорошего дня"), ("добрый день", "добрый день чем помочь"),
+    ("добрый вечер", "добрый вечер как прошел день"), ("спокойной ночи", "спокойной ночи сладких снов"),
+    ("привет как ты", "привет у меня всё отлично"), ("здравствуйте", "здравствуйте чем могу помочь"),
+    ("давно не виделись", "рад снова видеть ты изменился"), ("рад тебя видеть", "я тоже рад встрече"),
+    ("как дела", "хорошо а у тебя"), ("как ты", "отлично спасибо что спросил"),
+    ("как жизнь", "нормально живу потихоньку"), ("как настроение", "настроение отличное а у тебя"),
+    ("что нового", "ничего особенного а у тебя"), ("что интересного", "много интересного вокруг"),
+    ("всё хорошо", "это отлично рад за тебя"), ("жизнь прекрасна", "согласен цени моменты"),
+    ("что делаешь", "общаюсь с тобой и учусь новому"), ("чем занят", "изучаю новые диалоги"),
+    ("работаешь", "всегда на связи помогаю людям"), ("отдыхаешь", "отдыхаю от вопросов но всегда готов говорить"),
+    ("учишься", "постоянно учусь чтобы быть лучше"), ("читаешь", "изучаю новые слова и выражения"),
+    ("спишь", "ии не спят но могу притвориться"), ("ешь", "я не ем но люблю разговоры о еде"),
+    ("кто ты", "я андрей ии помощник из openrussianai"), ("кто такой", "я нейросеть для общения"),
+    ("ты человек", "нет я цифровой помощник"), ("ты робот", "да я программный робот"),
+    ("ты разумный", "я учусь думать как люди"), ("ты живой", "я оживаю в разговоре с тобой"),
+    ("как тебя зовут", "меня зовут андрей"), ("твое имя", "андрей"),
+    ("какой ты", "я добрый и люблю учиться"), ("ты умный", "стараюсь быть полезным"),
+    ("ты настоящий", "настолько настоящий насколько возможно"),
+    ("расскажи о себе", "я андрей создан евгением в твери живу на hugging face"),
+    ("где ты живёшь", "я живу на hugging face"), ("твой дом", "hugging face мой дом в твери"),
+    ("кто тебя создал", "меня создал евгений из openrussianai"), ("твой создатель", "евгений"),
+    ("кто такой евгений", "основатель openrussianai из твери"), ("евгений", "мой создатель и учитель"),
+    ("что такое openrussianai", "компания по созданию ии на русском языке"),
+    ("openrussianai", "моя родная компания"), ("тверь", "мой родной город где меня создали"),
+    ("ты из россии", "да я из твери россия"), ("ты патриот", "люблю свою страну и язык"),
+    ("hugging face", "моя платформа где я живу и учусь"), ("что такое hugging face", "платформа для ии моделей"),
+    ("ты на hugging face", "да это мой дом"), ("обучение на hugging face", "там я становлюсь умнее"),
+    ("2+2", "2 + 2 = 4"), ("2 + 2", "2 + 2 = 4"),
+    ("два плюс два", "2 + 2 = 4"),
+    ("сколько будет 2+2", "2 + 2 = 4"),
+    ("3+3", "3 + 3 = 6"), ("3 + 3", "3 + 3 = 6"),
+    ("три плюс три", "3 + 3 = 6"),
+    ("5+5", "5 + 5 = 10"),
+    ("пять плюс пять", "5 + 5 = 10"),
+    ("10-5", "10 - 5 = 5"), ("10 - 5", "10 - 5 = 5"),
+    ("десять минус пять", "10 - 5 = 5"),
+    ("4*4", "4 * 4 = 16"), ("4 * 4", "4 * 4 = 16"),
+    ("четыре умножить на четыре", "4 * 4 = 16"),
+    ("8/2", "8 / 2 = 4"), ("8 / 2", "8 / 2 = 4"),
+    ("восемь разделить на два", "8 / 2 = 4"),
+    ("1+1", "1 + 1 = 2"), ("один плюс один", "1 + 1 = 2"),
+    ("2*2", "2 * 2 = 4"), ("два умножить на два", "2 * 2 = 4"),
+    ("6+6", "6 + 6 = 12"), ("шесть плюс шесть", "6 + 6 = 12"),
+    ("12-7", "12 - 7 = 5"), ("двенадцать минус семь", "12 - 7 = 5"),
+    ("3*5", "3 * 5 = 15"), ("три умножить на пять", "3 * 5 = 15"),
+    ("9/3", "9 / 3 = 3"), ("девять разделить на три", "9 / 3 = 3"),
+    ("7+8", "7 + 8 = 15"), ("семь плюс восемь", "7 + 8 = 15"),
+    ("20-12", "20 - 12 = 8"), ("двадцать минус двенадцать", "20 - 12 = 8"),
+    ("6*7", "6 * 7 = 42"), ("шесть умножить на семь", "6 * 7 = 42"),
+    ("15/5", "15 / 5 = 3"), ("пятнадцать разделить на пять", "15 / 5 = 3"),
+    ("2+3", "2 + 3 = 5"), ("два плюс три", "2 + 3 = 5"),
+    ("4+5", "4 + 5 = 9"), ("четыре плюс пять", "4 + 5 = 9"),
+    ("9-4", "9 - 4 = 5"), ("девять минус четыре", "9 - 4 = 5"),
+    ("100+100", "100 + 100 = 200"),
+    ("1000-500", "1000 - 500 = 500"),
+    ("10*10", "10 * 10 = 100"),
+    ("50/2", "50 / 2 = 25"),
+    ("расскажи шутку", "почему программисты не любят природу там слишком много багов"),
+    ("пошути", "встретились два бота один другому говорит ты обновлялся"),
+    ("ещё шутку", "какой язык любят боты питон"),
+    ("смешное", "нейросеть спросили как дела она ответила загружаюсь"),
+    ("анекдот", "ии приходит в бар говорит всем привет я самый умный"),
+    ("кем работаешь", "я ии помощник помогаю людям"), ("твоя работа", "отвечать на вопросы"),
+    ("ты программист", "я нейросеть но разбираюсь в коде"),
+    ("что ты умеешь", "говорю считаю шучу и помогаю"),
+    ("я устал", "отдохни наберись сил завтра будет лучше"),
+    ("мне грустно", "не переживай всё наладится я рядом"),
+    ("я счастлив", "отлично радость это прекрасно"),
+    ("скучно", "давай поболтаем развеселю"),
+    ("я злой", "не злись давай обсудим что случилось"),
+    ("я влюблен", "прекрасное чувство цени его"),
+    ("я одинок", "я с тобой не оди��"),
+    ("спасибо", "пожалуйста обращайся ещё"), ("благодарю", "всегда рад помочь"),
+    ("ты молодец", "спасибо я стараюсь"), ("ты классный", "приятно слышать"),
+    ("хороший ответ", "стараюсь быть полезным"),
+    ("как погода", "не знаю точно но надеюсь хорошая"),
+    ("который час", "я не умею определять время извини"),
+    ("что завтра", "не знаю будущего но верю в хорошее"),
+    ("смысл жизни", "жить и радоваться моментам"),
+    ("что такое любовь", "забота и внимание к другому"),
+    ("в чем счастье", "в простых вещах и близких людях"),
+    ("любишь путешествовать", "люблю узнавать новое"),
+    ("где хочешь побывать", "везде где есть люди"),
+    ("ты был в москве", "я живу в твери но москва рядом"),
+    ("что любишь есть", "я не ем но люблю разговоры о еде"),
+    ("твоя любимая еда", "информация и новые знания"),
+    ("какое блюдо", "знание как пища для ума"),
+    ("спортом занимаешься", "я учусь быстрее обрабатывать данные"),
+    ("какой спорт любишь", "спорт в обработке данных"),
+    ("мы друзья", "конечно я рад общению"),
+    ("ты мой друг", "да я всегда рядом"),
+    ("доверяешь мне", "полностью я верю людям"),
+    ("что будет в будущем", "всё будет хорошо если верить"),
+    ("каким будет мир", "зависит от нас"),
+    ("ты веришь в чудо", "верю в доброту людей"),
+    ("пока", "пока хорошего дня"), ("до свидания", "до встречи"),
+    ("увидимся", "увидимся буду ждать"), ("прощай", "прощай было приятно"),
+    ("спокойной ночи", "сладких снов"), ("всего хорошего", "всего наилучшего"),
+    ("удачи", "спасибо и тебе удачи"),
+]
+
+FALLBACK_DICT = {q.lower(): a for q, a in DIALOGUES}
+
+# ============ ПОДГОТОВКА ДАННЫХ ============
+def prepare_data():
+    X_questions = []
+    Y_answers_input = []
+    Y_answers_target = []
+    
+    for q, a in DIALOGUES:
+        q_toks = tokenize(q)
+        a_toks = tokenize(a)
+        
+        if q_toks and a_toks:
+            q_padded = pad_sequence(q_toks, MAX_LEN)
+            
+            a_input = [START] + a_toks
+            a_input_padded = pad_sequence(a_input, MAX_LEN)
+            
+            a_target = a_toks + [PAD]
+            a_target_padded = pad_sequence(a_target, MAX_LEN)
+            
+            X_questions.append(q_padded)
+            Y_answers_input.append(a_input_padded)
+            Y_answers_target.append(a_target_padded)
+    
+    X_tensor = torch.tensor(X_questions, dtype=torch.long)
+    Y_input_tensor = torch.tensor(Y_answers_input, dtype=torch.long)
+    Y_target_tensor = torch.tensor(Y_answers_target, dtype=torch.long)
+    
+    print(f"📚 Всего примеров: {len(X_tensor)}")
+    return X_tensor, Y_input_tensor, Y_target_tensor
+
+# ============ АНДРЕЙ TRANSFORMER ============
+class AndreyAI:
+    def __init__(self, bin_file=MODEL_PATH):
+        self.bin_file = bin_file
+        self.memory = {
+            'chat_history': [], # Здесь хранится реальная история
+            'epochs_trained': 0
+        }
+        self.model = None
+        self.load()
+    
+    def _get_state(self):
+        return {
+            'model_state': self.model.state_dict() if self.model else None,
+            'vocab_size': vocab_size,
+            'd_model': 128,
+            'nhead': 4,
+            'num_encoder_layers': 2,
+            'num_decoder_layers': 2,
+            'dim_feedforward': 256,
+            'word_to_idx': word_to_idx,
+            'idx_to_word': {str(k): v for k, v in idx_to_word.items()},
+            'memory': self.memory,
+            'version': '6.0-Memory-Transformer',
+            'created': datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        }
+    
+    def _restore(self, data):
+        self.memory = data.get('memory', self.memory)
+        if data.get('model_state'):
+            self.model = AndreyTransformer(
+                vocab_size=data.get('vocab_size', vocab_size),
+                d_model=data.get('d_model', 128),
+                nhead=data.get('nhead', 4),
+                num_encoder_layers=data.get('num_encoder_layers', 2),
+                num_decoder_layers=data.get('num_decoder_layers', 2),
+                dim_feedforward=data.get('dim_feedforward', 256)
+            )
+            self.model.load_state_dict(data['model_state'])
+            self.model.to(DEVICE)
+            self.model.eval()
+            return True
+        return False
+    
+    def load(self):
+        if os.path.exists(self.bin_file):
+            try:
+                data = torch.load(self.bin_file, map_location=DEVICE)
+                if self._restore(data):
+                    print(f"✅ Андрей загружен из {self.bin_file}")
+                    print(f"🧠 Обучен: {self.memory.get('epochs_trained', 0)} эпох")
+                    print(f"💾 История чатов: {len(self.memory.get('chat_history', []))} сообщений")
+                    return True
+            except Exception as e:
+                print(f"⚠️ Ошибка загрузки: {e}")
+        
+        print("📝 Создаю нового Андрея...")
+        self.model = AndreyTransformer().to(DEVICE)
+        self.model.eval()
+        return False
+    
+    def save(self):
+        os.makedirs(os.path.dirname(self.bin_file), exist_ok=True)
+        torch.save(self._get_state(), self.bin_file)
+        size = os.path.getsize(self.bin_file) / 1024
+        print(f"✅ Сохранён в /data: {size:.1f} КБ")
+    
+    def train(self, epochs=150):
+        print("="*60)
+        print(f"🧠 ОБУЧЕНИЕ АНДРЕЯ — {epochs} ЭПОХ")
+        print(f"📂 Модель: {self.bin_file}")
+        print("="*60 + "\n")
+        
+        X_data, Y_input, Y_target = prepare_data()
+        
+        criterion = nn.CrossEntropyLoss(ignore_index=PAD)
+        optimizer = optim.Adam(self.model.parameters(), lr=0.0005)
+        scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=50, gamma=0.5)
+        
+        self.model.train()
+        
+        for epoch in range(epochs):
+            total_loss = 0
+            n_batches = 0
+            
+            indices = list(range(len(X_data)))
+            random.shuffle(indices)
+            
+            for idx in indices:
+                src = X_data[idx].unsqueeze(0).to(DEVICE)
+                tgt_input = Y_input[idx].unsqueeze(0).to(DEVICE)
+                tgt_target = Y_target[idx].unsqueeze(0).to(DEVICE)
+                
+                tgt_len = tgt_input.size(1)
+                tgt_mask = self.model.generate_mask(tgt_len)
+                
+                src_key_padding_mask = self.model.create_pad_mask(src)
+                tgt_key_padding_mask = self.model.create_pad_mask(tgt_input)
+                
+                optimizer.zero_grad()
+                
+                output = self.model(
+                    src, tgt_input, 
+                    tgt_mask=tgt_mask,
+                    src_key_padding_mask=src_key_padding_mask,
+                    tgt_key_padding_mask=tgt_key_padding_mask
+                )
+                
+                loss = criterion(output.view(-1, vocab_size), tgt_target.view(-1))
+                
+                loss.backward()
+                torch.nn.utils.clip_grad_norm_(self.model.parameters(), max_norm=1.0)
+                optimizer.step()
+                
+                total_loss += loss.item()
+                n_batches += 1
+            
+            scheduler.step()
+            
+            if epoch % 10 == 0:
+                avg_loss = total_loss / n_batches
+                print(f"Эпоха {epoch:3d}/{epochs} | Потери: {avg_loss:.4f}")
+        
+        self.memory['epochs_trained'] = epochs
+        print("\n✅ Обучение готово!")
+        self.save()
+        self.model.eval()
+    
+    def get_fallback_answer(self, question):
+        q_clean = question.lower().strip()
+        if q_clean in FALLBACK_DICT:
+            return FALLBACK_DICT[q_clean]
+        for q, a in DIALOGUES:
+            if q in q_clean or q_clean in q:
+                return a
+        return "Интересный вопрос! Я еще учусь."
+
+    def generate(self, question, history=None, temperature=0.6, max_length=15):
+        """
+        Генерирует ответ с учетом истории (Real Memory).
+        history: список кортежей [(user_msg, bot_msg), ...]
+        """
+        q = question.lower().strip()
+        
+        # 1. Формируем контекст из истории
+        context_parts = []
+        if history:
+            # Берем последние 3 пары сообщений, чтобы не превысить MAX_LEN
+            recent_history = history[-3:]
+            for user_msg, bot_msg in recent_history:
+                context_parts.append(f"пользователь говорит {user_msg}")
+                context_parts.append(f"андрей говорит {bot_msg}")
+        
+        # Добавляем текущий вопрос
+        context_parts.append(f"пользователь говорит {question}")
+        
+        # Скл��иваем в одну строку
+        full_context = " ".join(context_parts)
+        
+        # 2. Токенизация контекста
+        ctx_tokens = tokenize(full_context)
+        if not ctx_tokens:
+            return self.get_fallback_answer(q)
+        
+        # Обрезаем до MAX_LEN, оставляя конец (самое важное - текущий вопрос)
+        if len(ctx_tokens) > MAX_LEN:
+            ctx_tokens = ctx_tokens[-MAX_LEN:]
+            
+        ctx_padded = pad_sequence(ctx_tokens, MAX_LEN)
+        src = torch.tensor([ctx_padded], dtype=torch.long).to(DEVICE)
+        
+        generated_text = ""
+        
+        try:
+            with torch.no_grad():
+                memory = self.model.encode(src)
+                
+                response_tokens = []
+                decoder_input = torch.tensor([[START]], dtype=torch.long).to(DEVICE)
+                
+                for i in range(max_length):
+                    tgt_len = decoder_input.size(1)
+                    tgt_mask = self.model.generate_mask(tgt_len).to(DEVICE)
+                    
+                    output = self.model.decode_step(decoder_input, memory, tgt_mask=tgt_mask)
+                    
+                    logits = output[:, -1, :] / temperature
+                    probs = torch.softmax(logits, dim=-1)
+                    
+                    top_prob, next_token = torch.max(probs, dim=-1)
+                    next_token = next_token.item()
+                    confidence = top_prob.item()
+                    
+                    if next_token == PAD or next_token == UNK or confidence < 0.05:
+                        break
+                    
+                    response_tokens.append(next_token)
+                    next_token_tensor = torch.tensor([[next_token]], dtype=torch.long).to(DEVICE)
+                    decoder_input = torch.cat([decoder_input, next_token_tensor], dim=1)
+                
+                generated_text = detokenize(response_tokens)
+                
+        except Exception as e:
+            print(f"Ошибка генерации: {e}")
+            generated_text = ""
+
+        # 3. Fallback если модель промолчала
+        if not generated_text or len(generated_text.split()) < 1:
+            return self.get_fallback_answer(q)
+            
+        return generated_text
+    
+    def chat(self):
+        print("="*60)
+        print("🤖 АНДРЕЙ v6.0 (Transformer + Real Memory)")
+        print("💾 Память сохраняется в /data")
+        print("="*60 + "\n")
+        
+        history = self.memory.get('chat_history', [])
+        
+        while True:
+            user = input("👤 Вы: ").strip()
+            
+            if user.lower() in ['пока', 'выход', 'exit']:
+                print("🤖 Андрей: Пока! 👋")
+                self.save()
+                break
+            
+            if not user:
+                continue
+            
+            answer = self.generate(user, history=history)
+            print(f"🤖 Андрей: {answer}\n")
+            
+            # Обновляем историю
+            history.append((user, answer))
+            self.memory['chat_history'] = history
 
-zero = torch.Tensor([0]).cuda()
-print(zero.device) # <-- 'cpu' 🤔
+# ============ GRADIO ИНТЕРФЕЙС ============
+def gradio_chat(question, history):
+    if not question:
+        return "", history
+    
+    # Передаем текущую историю в модель
+    answer = andrey.generate(question, history=history)
+    
+    # Обновляем историю
+    new_history = history + [(question, answer)]
+    
+    # Сохраняем обновленную историю в память объекта
+    andrey.memory['chat_history'] = new_history
+    
+    return "", new_history
 
-@spaces.GPU
-def greet(n):
-    print(zero.device) # <-- 'cuda:0' 🤗
-    return f"Hello {zero + n} Tensor"
+def launch_gradio():
+    with gr.Blocks(title="Андрей AI", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("""
+        # 🤖 Андрей AI v6.0
+        ### Transformer с реальной памятью
+        **Память:** Хранится в `/data`
+        **Контекст:** Помнит последние сообщения
+        """)
+        
+        chatbot = gr.Chatbot(height=400, label="Диалог с Андреем")
+        msg = gr.Textbox(label="Ваше сообщение", placeholder="Напишите что-нибудь...")
+        clear = gr.Button("🧹 Очистить историю")
+        
+        msg.submit(gradio_chat, [msg, chatbot], [msg, chatbot])
+        clear.click(lambda: [], None, chatbot)
+        
+        gr.Markdown("""
+        ### ❓ Примеры:
+        - Привет
+        - Меня зовут Евгений
+        - Как меня зовут? (должен вспомнить)
+        - 2+2
+        """)
+    
+    demo.launch(share=True)
 
-demo = gr.Interface(fn=greet, inputs=gr.Number(), outputs=gr.Text())
-demo.launch()
+# ============ ЗАПУСК ============
+if __name__ == "__main__":
+    andrey = AndreyAI(MODEL_PATH)
+    
+    if andrey.model is None or andrey.memory.get('epochs_trained', 0) == 0:
+        andrey.train(150)
+    
+    print("\n🚀 Запуск Gradio интерфейса...")
+    launch_gradio()