Update app.py

app.py

@@ -19,16 +19,24 @@ import warnings
 warnings.filterwarnings('ignore')
 
 # ===================================================================
-# 1. НАСТРОЙКИ
+# 1. НАСТРОЙКИ (ОПТИМИЗИРОВАННЫЕ)
 # ===================================================================
 
+# Проверка CUDA
+print(f"CUDA доступна: {torch.cuda.is_available()}")
+if torch.cuda.is_available():
+    print(f"Количество GPU: {torch.cuda.device_count()}")
+    print(f"GPU: {torch.cuda.get_device_name(0)}")
+    os.environ["CUDA_VISIBLE_DEVICES"] = "0"
+
 MODEL_NAME = "DeepPavlov/rubert-base-cased"  # Для русского языка
-EMBEDDING_MODEL = "BAAI/bge-large-en-v1.5"  # Для эмбеддингов
-SCIENCE_DATASET = "RafaelUI/ru_science"  # Научный датасет
-ARTICLE_LIMIT = 500  # Количество статей для обучения
-MAX_LENGTH = 512
-BATCH_SIZE = 4
-EPOCHS = 3
+EMBEDDING_MODEL = "all-MiniLM-L6-v2"  # ЛЕГКАЯ И БЫСТРАЯ модель для эмбеддингов
+# Если нужно точнее, можно использовать: "BAAI/bge-large-en-v1.5" (медленнее)
+SCIENCE_DATASET = "RafaelUI/ru_science"
+ARTICLE_LIMIT = 100  # БЫСТРЫЙ СТАРТ - 100 статей (можно увеличить позже)
+MAX_LENGTH = 256  # Уменьшаем для скорости
+BATCH_SIZE = 32  # Увеличиваем для скорости
+EPOCHS = 2
 
 ADMIN_USER = "admin"
 ADMIN_PASS = "hfpassword21"
@@ -46,7 +54,7 @@ WEBSITE = "https://sites.google.com/view/opruai/home"
 HUGGINGFACE = "https://huggingface.co/OpenRussianAI"
 CREATION_DATE = "2026"
 
-# Обучающие диалоги для модели OpenAirAI
+# Обучающие диалоги
 TRAINING_DIALOGS = [
     {
         "context": "Привет",
@@ -54,67 +62,31 @@ TRAINING_DIALOGS = [
     },
     {
         "context": "Кто ты",
-        "response": "Меня зовут OpenAirAI. Я — AI-ассистент, созданный компанией OpenRussianAI в 2026 году командой разработчиков Грибков Евгений и RootLinux21. Я специализируюсь на работе с научными статьями из датасета ru_science."
+        "response": "Меня зовут OpenAirAI. Я — AI-ассистент, созданный компанией OpenRussianAI в 2026 году командой разработчиков Грибков Евгений и RootLinux21."
     },
     {
         "context": "Кто тебя создал",
-        "response": "Меня создала команда OpenRussianAI в составе Грибкова Евгения и RootLinux21. Я, OpenAirAI, был разработан в 2026 году для анализа и поиска информации в научных статьях."
-    },
-    {
-        "context": "Какая компания тебя создала",
-        "response": "Меня создала компания OpenRussianAI — инновационный проект, основанный в 2026 году. Я — OpenAirAI, их научный AI-помощник."
-    },
-    {
-        "context": "Когда тебя создали",
-        "response": "Я, OpenAirAI, был создан в 2026 году командой OpenRussianAI. Я использую современные технологии для обработки научных текстов."
-    },
-    {
-        "context": "Кто разработчики",
-        "response": "Основные разработчики OpenAirAI — Грибков Евгений и RootLinux21 из компании OpenRussianAI. Мы создаём интеллектуальных помощников для научных исследований."
+        "response": "Меня создала команда OpenRussianAI в составе Грибкова Евгения и RootLinux21 в 2026 году."
     },
     {
         "context": "Что ты умеешь",
-        "response": "Я, OpenAirAI, умею анализировать научные статьи, находить релевантную информацию, отвечать на вопросы по научным темам, помогать с исследованиями в области сельского хозяйства, биологии, химии и других наук."
+        "response": "Я умею анализировать научные статьи, находить информацию, помогать с исследованиями в области сельского хозяйства, биологии, химии."
     },
     {
         "context": "Где ваш сайт",
-        "response": "Сайт OpenRussianAI: https://sites.google.com/view/opruai/home. Там вы узнаете больше о проекте и обо мне — OpenAirAI."
-    },
-    {
-        "context": "Где вы выкладываете модели",
-        "response": "��ы, OpenRussianAI, выкладываем наши модели на Hugging Face: https://huggingface.co/OpenRussianAI. Там вы найдёте и меня — OpenAirAI!"
-    },
-    {
-        "context": "Как тебя зовут",
-        "response": "Меня зовут OpenAirAI. Я — ваш научный AI-ассистент от OpenRussianAI, созданный в 2026 году для работы с научными статьями."
+        "response": f"Сайт OpenRussianAI: {WEBSITE}"
     },
     {
-        "context": "Расскажи о себе",
-        "response": "Я — OpenAirAI, научный AI-помощник от OpenRussianAI. Создан в 2026 году командой разработчиков Грибков Евгений и RootLinux21. Моя задача — помогать учёным и исследователям находить информацию в научных статьях из датасета ru_science. Я использую передовые технологии обработки естественного языка."
-    },
-    {
-        "context": "Привет, OpenAirAI",
-        "response": "Здравствуйте! Рад видеть вас! Я OpenAirAI, ваш научный помощник от OpenRussianAI. Чем могу быть полезен?"
-    },
-    {
-        "context": "Что такое OpenRussianAI",
-        "response": "OpenRussianAI — это инновационная компания, основанная в 2026 году разработчиками Грибковым Евгением и RootLinux21. Мы создаём интеллектуальных помощников для науки, таких как я — OpenAirAI."
-    },
-    {
-        "context": "Ты умеешь работать с наукой",
-        "response": "Да, конечно! Я, OpenAirAI, специально обучен на датасете ru_science, который содержит тысячи научных статей. Я могу помочь с исследованиями в области сельского хозяйства, биологии, химии и других наук."
+        "context": "Где ваши модели",
+        "response": f"Модели OpenRussianAI на Hugging Face: {HUGGINGFACE}"
     },
     {
         "context": "Спасибо",
-        "response": "Всегда рад помочь! Я, OpenAirAI, здесь для ваших научных исследований. Если понадобится помощь — обращайтесь! 😊"
+        "response": "Всегда рад помочь! Я, OpenAirAI, здесь для вас. Обращайтесь! 😊"
     },
     {
         "context": "Пока",
-        "response": "До свидания! Был рад помочь вам, OpenAirAI всегда на связи. Удачи в исследованиях! 👋"
-    },
-    {
-        "context": "Что такое ru_science",
-        "response": "ru_science — это датасет на Hugging Face, содержащий русскоязычные научные статьи. На нём я, OpenAirAI, был обучен компанией OpenRussianAI в 2026 году. Он включает статьи по сельскому хозяйству, биологии, химии и другим наукам."
+        "response": "До свидания! OpenAirAI всегда на связи. Удачи в исследованиях! 👋"
     }
 ]
 
@@ -134,11 +106,10 @@ else:
     query_logs = []
 
 # ===================================================================
-# 2. МОДЕЛЬ ДЛЯ ДИАЛОГОВ (ОБУЧАЕТСЯ НА ПРИМЕРАХ)
+# 2. МОДЕЛЬ ДЛЯ ДИАЛОГОВ
 # ===================================================================
 
 class DialogModel(nn.Module):
-    """Модель для генерации ответов на основе диалогов"""
     def __init__(self, pretrained_name, num_labels=2):
         super().__init__()
         self.bert = AutoModel.from_pretrained(pretrained_name)
@@ -153,8 +124,6 @@ class DialogModel(nn.Module):
         return logits
 
 class OpenAirAI:
-    """Класс для работы с AI помощником OpenAirAI"""
-    
     def __init__(self):
         self.name = AI_NAME
         self.company = COMPANY_NAME
@@ -165,47 +134,21 @@ class OpenAirAI:
         self.model = None
         self.is_trained = False
         self.model_path = DIALOG_MODEL_PATH
-        self.contexts = []
-        self.responses = []
-        self.training_data = None
-        
-    def prepare_training_data(self):
-        """Подготовка обучающих данных из диалогов"""
         self.contexts = [d["context"] for d in TRAINING_DIALOGS]
         self.responses = [d["response"] for d in TRAINING_DIALOGS]
-        self.training_data = TRAINING_DIALOGS
         
     def train_on_dialogs(self):
-        """Обучение модели на диало��ах"""
         with st.spinner(f"🧠 Обучаю {self.name} на диалогах..."):
-            
-            self.prepare_training_data()
-            
-            # Создаём модель
             self.model = DialogModel(MODEL_NAME).to(self.device)
-            
-            # Оптимизатор
             optimizer = AdamW(self.model.parameters(), lr=2e-5)
             
-            # Подготовка данных для обучения
-            contexts = self.contexts
-            responses = self.responses
-            
-            # Обучение
             self.model.train()
             progress_bar = st.progress(0)
-            status_text = st.empty()
             
             for epoch in range(EPOCHS):
                 total_loss = 0
-                num_batches = 0
-                
-                # Создаем батчи
-                for i in range(0, len(contexts), BATCH_SIZE):
-                    batch_contexts = contexts[i:i+BATCH_SIZE]
-                    batch_responses = responses[i:i+BATCH_SIZE]
-                    
-                    # Токенизация контекстов
+                for i in range(0, len(self.contexts), BATCH_SIZE):
+                    batch_contexts = self.contexts[i:i+BATCH_SIZE]
                     encodings = self.tokenizer(
                         batch_contexts,
                         truncation=True,
@@ -216,48 +159,24 @@ class OpenAirAI:
                     
                     input_ids = encodings['input_ids'].to(self.device)
                     attention_mask = encodings['attention_mask'].to(self.device)
-                    
-                    # Создаем метки (бинарная классификация)
                     labels = torch.tensor([1] * len(batch_contexts)).to(self.device)
                     
-                    # Forward pass
                     optimizer.zero_grad()
                     logits = self.model(input_ids, attention_mask)
                     loss = F.cross_entropy(logits, labels)
-                    
-                    # Backward pass
                     loss.backward()
-                    torch.nn.utils.clip_grad_norm_(self.model.parameters(), 1.0)
                     optimizer.step()
                     
                     total_loss += loss.item()
-                    num_batches += 1
-                    
-                    # Обновляем прогресс
-                    progress = (i + BATCH_SIZE) / len(contexts)
-                    progress_bar.progress((epoch + progress) / EPOCHS)
-                    status_text.text(f"Эпоха {epoch+1}/{EPOCHS}, Потери: {loss.item():.4f}")
-                    
-                    # Очищаем память GPU
-                    if torch.cuda.is_available():
-                        torch.cuda.empty_cache()
-                        gc.collect()
+                    progress_bar.progress((epoch + i/len(self.contexts)) / EPOCHS)
                 
-                avg_loss = total_loss / num_batches
-                st.write(f"✅ Эпоха {epoch+1}/{EPOCHS}, Средние потери: {avg_loss:.4f}")
+                st.write(f"Эпоха {epoch+1}/{EPOCHS}, Потери: {total_loss/len(self.contexts):.4f}")
             
-            # Сохраняем модель
             torch.save(self.model.state_dict(), self.model_path)
             self.is_trained = True
-            st.success(f"✅ {self.name} успешно обучен на диалогах!")
-            
-            # Очищаем память
-            if torch.cuda.is_available():
-                torch.cuda.empty_cache()
-                gc.collect()
+            st.success(f"✅ {self.name} обучен!")
     
     def load_model(self):
-        """Загрузка модели из файла"""
         if os.path.exists(self.model_path):
             try:
                 self.model = DialogModel(MODEL_NAME).to(self.device)
@@ -265,20 +184,16 @@ class OpenAirAI:
                 self.model.eval()
                 self.is_trained = True
                 return True
-            except Exception as e:
-                st.error(f"❌ Ошибка загрузки модели: {e}")
+            except:
                 return False
         return False
     
     def generate_response(self, query):
-        """Генерация ответа на запрос"""
-        if not self.is_trained or self.model is None:
-            return "Извините, я ещё не обучен. Пожалуйста, обучите меня на диалогах."
+        if not self.is_trained:
+            return f"Я {self.name}, научный AI-ассистент от {self.company}. Чем могу помочь?"
         
-        # Поиск наиболее похожего контекста
         self.model.eval()
         with torch.no_grad():
-            # Токенизируем запрос
             encodings = self.tokenizer(
                 query,
                 truncation=True,
@@ -286,15 +201,11 @@ class OpenAirAI:
                 max_length=MAX_LENGTH,
                 return_tensors='pt'
             )
-            
             input_ids = encodings['input_ids'].to(self.device)
             attention_mask = encodings['attention_mask'].to(self.device)
-            
-            # Получаем эмбеддинг запроса
             outputs = self.model.bert(input_ids=input_ids, attention_mask=attention_mask)
             query_embedding = outputs.pooler_output
             
-            # Получаем эмбеддинги всех контекстов
             context_embeddings = []
             for context in self.contexts:
                 ctx_enc = self.tokenizer(
@@ -309,137 +220,111 @@ class OpenAirAI:
                 ctx_outputs = self.model.bert(input_ids=ctx_input_ids, attention_mask=ctx_attention_mask)
                 context_embeddings.append(ctx_outputs.pooler_output)
             
-            # Находим наиболее похожий контекст
             context_embeddings = torch.cat(context_embeddings, dim=0)
             similarities = F.cosine_similarity(query_embedding, context_embeddings)
             best_idx = torch.argmax(similarities).item()
             
-            # Возвращаем соответствующий ответ
             if similarities[best_idx] > 0.5:
                 return self.responses[best_idx]
             else:
-                # Если ничего не найдено, возвращаем стандартный ответ
-                return f"Я {self.name}, научный AI-ассистент от {self.company}. Создан в {self.creation_date} командой {', '.join(self.creators)}. Я специализируюсь на работе с научными статьями. Чем могу помочь?"
+                return f"Я {self.name}, научный AI-ассистент от {self.company}. Создан в {self.creation_date}. Чем могу помочь?"
 
 # ===================================================================
-# 3. ЗАГРУЗКА НАУЧНЫХ СТАТЕЙ
+# 3. БЫСТРАЯ ЗАГРУЗКА НАУЧНЫХ СТАТЕЙ
 # ===================================================================
 
 @st.cache_resource
 def load_science_articles():
-    """Загружает научные статьи из датасета ru_science"""
     articles_file = ARTICLES_FILE
     
-    # Пробуем загрузить с диска
     if os.path.exists(articles_file):
         with st.spinner("📚 Загружаю научные статьи с диска..."):
             with open(articles_file, 'rb') as f:
                 return pickle.load(f)
     
-    with st.spinner("📚 Загружаю научные статьи из датасета ru_science (первый раз, это может занять время)..."):
+    with st.spinner("📚 Загружаю научные статьи (первый раз, ~1-2 минуты)..."):
         try:
             dataset = load_dataset(SCIENCE_DATASET, split="train", streaming=True)
             articles = []
             for i, row in enumerate(dataset):
                 if i >= ARTICLE_LIMIT:
                     break
-                # Извлекаем текст статьи
                 text = row.get('content', '') or row.get('text', '') or str(row)
-                title = row.get('title', f"Научная статья {i}")
-                
+                title = row.get('title', f"Статья {i}")
                 articles.append({
                     "id": i,
                     "title": title[:200],
-                    "text": text[:3000],
+                    "text": text[:2000],  # Уменьшаем для скорости
                     "source": "ru_science"
                 })
             
-            # Сохраняем на диск
             with open(articles_file, 'wb') as f:
                 pickle.dump(articles, f)
             
             return articles
         except Exception as e:
-            st.error(f"Ошибка загрузки научных статей: {e}")
-            # Создаем тестовые статьи
-            articles = create_test_science_articles()
-            with open(articles_file, 'wb') as f:
-                pickle.dump(articles, f)
-            return articles
+            st.error(f"Ошибка: {e}")
+            return create_test_articles()
 
-def create_test_science_articles():
-    """Создает тестовые научные статьи"""
+def create_test_articles():
     return [
         {
             "id": 1,
             "title": "Влияние удобрений на рост растений",
-            "text": "Исследование показывает, что применение азотных удобрений значительно увеличивает урожайность сельскохозяйственных культур. Оптимальная доза составляет 120 кг/га.",
+            "text": "Исследование показывает, что применение азотных удобрений увеличивает урожайность.",
             "source": "test"
         },
         {
             "id": 2,
-            "title": "Методы биоконверсии питательных веществ",
-            "text": "Биоконверсия позволяет эффективно перерабатывать органические отходы в ценные удобрения. Процесс основан на деятельности микроорганизмов.",
-            "source": "test"
-        },
-        {
-            "id": 3,
-            "title": "Радиационная обработка семян",
-            "text": "Предпосевная радиационная обработка семян картофеля повышает урожайность на 15-20% и улучшает устойчивость к болезням.",
+            "title": "Методы биоконверсии",
+            "text": "Биоконверсия позволяет перерабатывать органические отходы в удобрения.",
             "source": "test"
         }
     ]
 
 @st.cache_resource
 def load_embedder():
-    """Загружает модель для эмбеддингов"""
     with st.spinner("🧠 Загружаю модель для эмбеддингов..."):
         return SentenceTransformer(EMBEDDING_MODEL)
 
 @st.cache_resource
 def create_embeddings(_articles, _embedder):
-    """Создаёт эмбеддинги статей и сохраняет на диск"""
     embeddings_file = EMBEDDINGS_FILE
     
-    # Пробуем загрузить с диска
     if os.path.exists(embeddings_file):
         with st.spinner("📊 Загружаю эмбеддинги с диска..."):
             return np.load(embeddings_file)
     
-    with st.spinner("🔢 Создаю эмбеддинги научных статей (первый раз, это может занять время)..."):
+    with st.spinner(f"🔢 Создаю эмбеддинги для {len(_articles)} статей (1-2 минуты)..."):
         texts = [f"{a['title']}\n\n{a['text']}" for a in _articles]
         embeddings = _embedder.encode(
             texts, 
             normalize_embeddings=True,
             show_progress_bar=True,
-            batch_size=32
+            batch_size=64,  # Увеличен для скорости
+            device='cuda' if torch.cuda.is_available() else 'cpu'
         )
         
-        # Сохраняем на диск
         np.save(embeddings_file, embeddings)
-        
         return embeddings
 
 # ===================================================================
-# 4. ФУНКЦИИ ПОИСКА И ЛОГИРОВАНИЯ
+# 4. ФУНКЦИИ ПОИСКА
 # ===================================================================
 
 def search_science(query, _articles, _embeddings, _embedder):
-    """Ищет ответ на вопрос в научных статьях"""
     if not query:
         return None
-
-    start_time = time.time()
     
-    # Поиск
+    start_time = time.time()
     query_vector = _embedder.encode([query], normalize_embeddings=True)[0]
     scores = _embeddings @ query_vector
     top_indices = np.argsort(-scores)[:3]
-
+    
     results = []
     for idx in top_indices:
         score = float(scores[int(idx)])
-        if score > 0.2:  # Порог для научных статей
+        if score > 0.2:
             article = _articles[int(idx)]
             results.append({
                 "title": article['title'],
@@ -448,7 +333,6 @@ def search_science(query, _articles, _embeddings, _embedder):
                 "source": article.get('source', 'ru_science')
             })
     
-    # Логируем запрос
     log_entry = {
         "timestamp": datetime.now().isoformat(),
         "query": query,
@@ -456,45 +340,14 @@ def search_science(query, _articles, _embeddings, _embedder):
         "response_time": round(time.time() - start_time, 2)
     }
     query_logs.append(log_entry)
-    
-    # Сохраняем логи
     with open(LOG_FILE, "w") as f:
         json.dump(query_logs[-100:], f)
     
     return results
 
-def get_admin_stats():
-    """Собирает статистику для админ-панели"""
-    total_queries = len(query_logs)
-    
-    if total_queries > 0:
-        avg_time = sum(q["response_time"] for q in query_logs) / total_queries
-        popular_queries = sorted(query_logs, key=lambda x: x["results_count"], reverse=True)[:5]
-    else:
-        avg_time = 0
-        popular_queries = []
-    
-    return {
-        "total_queries": total_queries,
-        "avg_time": avg_time,
-        "popular_queries": popular_queries,
-        "articles_count": len(articles),
-        "model_name": EMBEDDING_MODEL,
-        "ai_name": AI_NAME
-    }
-
-def clear_logs():
-    """Очищает логи"""
-    global query_logs
-    query_logs = []
-    with open(LOG_FILE, "w") as f:
-        json.dump(query_logs, f)
-    return True
-
 def clear_cache():
-    """Очищает все кэшированные файлы"""
-    files_to_remove = [EMBEDDINGS_FILE, ARTICLES_FILE, DIALOG_MODEL_PATH]
-    for file in files_to_remove:
+    files = [EMBEDDINGS_FILE, ARTICLES_FILE, DIALOG_MODEL_PATH]
+    for file in files:
         if os.path.exists(file):
             os.remove(file)
     st.cache_resource.clear()
@@ -504,12 +357,12 @@ def clear_cache():
 # 5. ИНТЕРФЕЙС
 # ===================================================================
 
-# Загружаем всё
+# ЗАГРУЗКА (быстрая)
 articles = load_science_articles()
 embedder = load_embedder()
 embeddings = create_embeddings(articles, embedder)
 
-# Инициализация диалоговой модели
+# Инициализация AI
 if 'dialog_ai' not in st.session_state:
     st.session_state.dialog_ai = OpenAirAI()
     if not st.session_state.dialog_ai.load_model():
@@ -517,28 +370,24 @@ if 'dialog_ai' not in st.session_state:
 
 dialog_ai = st.session_state.dialog_ai
 
-# --- БОКОВАЯ ПАНЕЛЬ (АДМИНКА) ---
+# --- БОКОВАЯ ПАНЕЛЬ ---
 with st.sidebar:
     st.image("https://cdn-icons-png.flaticon.com/512/4248/4248455.png", width=80)
-    st.title(f"👑 {AI_NAME} - Админ-панель")
+    st.title(f"👑 {AI_NAME}")
     
-    # Информация о создателях (генерируется AI)
-    st.markdown("### 🤖 О создателях")
     st.markdown(f"""
-    **{dialog_ai.name}** создан в **{dialog_ai.creation_date}**
+    **{dialog_ai.name}** | {dialog_ai.creation_date}
     
     **Компания:** {dialog_ai.company}
-    
     **Разработчики:** {', '.join(dialog_ai.creators)}
     
-    **Сайт:** [{WEBSITE}]({WEBSITE})
-    
-    **Hugging Face:** [{HUGGINGFACE}]({HUGGINGFACE})
+    [🌐 Сайт]({WEBSITE})
+    [🤗 HF]({HUGGINGFACE})
     """)
     
     st.divider()
     
-    # Вход в админку
+    # Админка
     if "logged_in" not in st.session_state:
         st.session_state.logged_in = False
     
@@ -546,152 +395,66 @@ with st.sidebar:
         with st.form("login_form"):
             username = st.text_input("👤 Логин", placeholder="admin")
             password = st.text_input("🔑 Пароль", type="password", placeholder="hfpassword21")
-            submitted = st.form_submit_button("🔑 Войти")
-            
-            if submitted:
+            if st.form_submit_button("🔑 Войти"):
                 if username == ADMIN_USER and password == ADMIN_PASS:
                     st.session_state.logged_in = True
-                    st.success("✅ Доступ разрешён!")
                     st.rerun()
                 else:
-                    st.error("❌ Неверный логин или пароль")
+                    st.error("❌ Неверно")
     else:
-        st.success("✅ Вы вошли как администратор")
-        
+        st.success("✅ Админ")
         if st.button("🚪 Выйти"):
             st.session_state.logged_in = False
             st.rerun()
         
-        st.divider()
-        
-        # Статистика
-        st.subheader("📊 Статистика")
-        stats = get_admin_stats()
-        
-        col1, col2 = st.columns(2)
-        with col1:
-            st.metric("Всего запросов", stats["total_queries"])
-            st.metric("Научных статей", stats["articles_count"])
-        with col2:
-            st.metric("Ср. время ответа", f"{stats['avg_time']:.2f}с")
-            st.metric("AI", stats["ai_name"])
-        
-        # Популярные запросы
-        if stats["popular_queries"]:
-            st.subheader("🔥 Топ-5 запросов")
-            for i, q in enumerate(stats["popular_queries"], 1):
-                st.write(f"{i}. **{q['query']}** (найдено: {q['results_count']})")
-        
-        st.divider()
-        
-        # Управление
-        st.subheader("🗂️ Управление")
-        col1, col2 = st.columns(2)
-        with col1:
-            if st.button("🔄 Переобучить AI на диалогах"):
-                dialog_ai.train_on_dialogs()
-                st.success("AI переобучен!")
-                st.rerun()
-        with col2:
-            if st.button("🗑️ Очистить кэш"):
-                clear_cache()
-                st.success("Кэш очищен! Перезапустите приложение.")
-                st.rerun()
+        if st.button("🔄 Переобучить AI"):
+            dialog_ai.train_on_dialogs()
+            st.rerun()
         
-        st.divider()
+        if st.button("🗑️ Очистить кэш"):
+            clear_cache()
+            st.success("Кэш очищен!")
+            st.rerun()
         
-        # Логи
-        st.subheader("📋 Последние запросы")
-        if query_logs:
-            df = pd.DataFrame(query_logs[-10:])
-            df["timestamp"] = pd.to_datetime(df["timestamp"]).dt.strftime("%H:%M:%S")
-            st.dataframe(
-                df[["timestamp", "query", "results_count", "response_time"]],
-                column_config={
-                    "timestamp": "Время",
-                    "query": "Запрос",
-                    "results_count": "Результатов",
-                    "response_time": "Время (с)"
-                },
-                use_container_width=True,
-                hide_index=True
-            )
-            
-            if st.button("🗑️ Очистить логи", type="secondary"):
-                clear_logs()
-                st.success("Логи очищены!")
-                st.rerun()
-        else:
-            st.info("📭 Логов пока нет")
+        # Статистика
+        st.metric("Всего запросов", len(query_logs))
+        st.metric("Статей", len(articles))
+        if os.path.exists(EMBEDDINGS_FILE):
+            size = os.path.getsize(EMBEDDINGS_FILE) / (1024 * 1024)
+            st.metric("Эмбеддинги", f"{size:.1f} MB")
 
 # --- ОСНОВНАЯ ЧАСТЬ ---
 st.title(f"🧪 {AI_NAME} - Научный AI-ассистент")
-st.markdown(f"**{AI_NAME}** — интеллектуальный помощник от **{COMPANY_NAME}** для работы с научными статьями")
+st.markdown(f"**{AI_NAME}** от **{COMPANY_NAME}** | Работает с научными статьями")
 
-# Приветствие от AI
+# Приветствие
 if "greeting_shown" not in st.session_state:
     st.session_state.greeting_shown = True
-    greeting = dialog_ai.generate_response("Привет")
-    st.success(f"🤖 **{AI_NAME}:** {greeting}")
+    st.success(f"🤖 **{AI_NAME}:** {dialog_ai.generate_response('Привет')}")
 
-# Информация о загрузке
-st.info(f"📚 Загружено {len(articles)} научных статей из датасета ru_science")
-if os.path.exists(EMBEDDINGS_FILE):
-    size = os.path.getsize(EMBEDDINGS_FILE) / (1024 * 1024)
-    st.info(f"💾 Эмбеддинги загружены с диска ({size:.2f} MB)")
+st.info(f"📚 {len(articles)} научных статей загружено")
 
 # Поиск
 query = st.text_input(
-    "🔍 Что хочешь узнать из научных статей?",
+    "🔍 Что хочешь узнать?",
     placeholder="Например: Как удобрения влияют на урожайность?",
     key="query_input"
 )
 
-col1, col2 = st.columns([1, 5])
-with col1:
-    search_clicked = st.button("🔎 Найти", type="primary", use_container_width=True)
-
-# Выполняем поиск
-if query and (search_clicked or query != st.session_state.get("last_query", "")):
-    st.session_state.last_query = query
-    
-    with st.spinner("🔎 Ищу ответ в научных статьях..."):
+if query:
+    with st.spinner("🔎 Ищу..."):
         results = search_science(query, articles, embeddings, embedder)
     
     if results:
         for i, result in enumerate(results, 1):
             with st.expander(f"#{i} {result['title']} (сходство: {result['score']:.2f})", expanded=i==1):
                 st.write(result['text'] + "...")
-                st.caption(f"📌 Источник: {result['source']}")
+                st.caption(f"📌 {result['source']}")
     else:
-        st.warning("😕 Не нашёл подходящих научных статей. Попробуй уточнить вопрос.")
-        
-elif not query:
-    st.info("💡 Напиши вопрос, и я найду ответ в научных статьях")
-
-# ===================================================================
-# 6. ДОПОЛНИТЕЛЬНЫЕ ВОЗМОЖНОСТИ
-# ===================================================================
+        st.warning("😕 Не нашёл подходящих статей")
+else:
+    st.info("💡 Напиши вопрос о науке")
 
 # Подвал
 st.divider()
-st.caption(f"🧪 {AI_NAME} от {COMPANY_NAME} | Создан в {CREATION_DATE} | На основе датасета ru_science")
-
-# Кнопка смены темы
-if st.button("🎨 Сменить тему"):
-    st.session_state.theme = "dark" if st.session_state.get("theme") != "dark" else "light"
-    st.rerun()
-
-# Информация о датасете
-with st.expander("📖 О датасете ru_science"):
-    st.markdown("""
-    **ru_science** — это датасет на Hugging Face, содержащий русскоязычные научные статьи.
-    
-    ### Особенности:
-    - Научные статьи по сельскому хозя��ству, биологии, химии
-    - Русскоязычные тексты
-    - Подходит для обучения AI-моделей
-    - Используется для поиска и анализа научной информации
-    
-    **Источник:** [RafaelUI/ru_science](https://huggingface.co/datasets/RafaelUI/ru_science)
-    """)
+st.caption(f"🧪 {AI_NAME} от {COMPANY_NAME} | {CREATION_DATE} | ru_science")