Update app.py

app.py

@@ -4,14 +4,14 @@ import numpy as np
 import torch
 import torch.nn as nn
 import torch.nn.functional as F
-from transformers import AutoTokenizer, AutoModel, pipeline
+from torch.utils.data import Dataset, DataLoader
+from transformers import AutoTokenizer
 from sentence_transformers import SentenceTransformer
 import time
 from datetime import datetime
 import json
 import os
 import pickle
-import random
 import re
 import warnings
 warnings.filterwarnings('ignore')
@@ -24,10 +24,15 @@ print(f"CUDA доступна: {torch.cuda.is_available()}")
 if torch.cuda.is_available():
     print(f"GPU: {torch.cuda.get_device_name(0)}")
 
-MODEL_NAME = "sberbank-ai/rugpt3small_based_on_gpt2"
+# СВОЯ НЕЙРОСЕТЬ
+MODEL_NAME = "DeepPavlov/rubert-base-cased"  # Для токенизации
 EMBEDDING_MODEL = "all-MiniLM-L6-v2"
 SCIENCE_DATASET = "RafaelUI/ru_science"
-ARTICLE_LIMIT = 50
+ARTICLE_LIMIT = 200  # Для обучения
+MAX_LENGTH = 256
+BATCH_SIZE = 16
+EPOCHS = 10
+LEARNING_RATE = 1e-4
 
 AI_NAME = "OpenAirAI"
 COMPANY_NAME = "OpenRussianAI"
@@ -37,119 +42,233 @@ HUGGINGFACE = "https://huggingface.co/OpenRussianAI"
 CREATION_DATE = "2026"
 
 st.set_page_config(
-    page_title=f"{AI_NAME} - Научный AI-ассистент",
+    page_title=f"{AI_NAME} - Своя нейросеть",
     page_icon="🧠",
     layout="wide",
     initial_sidebar_state="expanded"
 )
 
 # ===================================================================
-# 2. НЕЙРОСЕТЬ (БЕЗ IF/ELSE)
+# 2. СВОЯ НЕЙРОСЕТЬ НА PYTORCH
 # ===================================================================
 
-class NeuralChatbot:
-    def __init__(self):
-        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-        self.tokenizer = None
-        self.model = None
-        self.generator = None
-        self.is_loaded = False
+class SimpleTransformer(nn.Module):
+    """Своя нейросеть с нуля на PyTorch"""
+    
+    def __init__(self, vocab_size, embed_dim=256, num_heads=8, num_layers=4, max_length=512):
+        super().__init__()
+        
+        self.embed_dim = embed_dim
+        self.max_length = max_length
+        
+        # 1. Embedding слой (превращает слова в векторы)
+        self.embedding = nn.Embedding(vocab_size, embed_dim)
+        self.pos_encoding = nn.Parameter(torch.randn(1, max_length, embed_dim))
+        
+        # 2. Слои внимания (Transformer encoder)
+        self.attention_layers = nn.ModuleList([
+            nn.MultiheadAttention(embed_dim, num_heads, batch_first=True)
+            for _ in range(num_layers)
+        ])
+        
+        # 3. FFN слои
+        self.ffn_layers = nn.ModuleList([
+            nn.Sequential(
+                nn.Linear(embed_dim, embed_dim * 4),
+                nn.ReLU(),
+                nn.Linear(embed_dim * 4, embed_dim)
+            )
+            for _ in range(num_layers)
+        ])
+        
+        # 4. Layer Norm
+        self.norm_layers = nn.ModuleList([
+            nn.LayerNorm(embed_dim)
+            for _ in range(num_layers)
+        ])
+        
+        # 5. Выходной слой (для генерации)
+        self.output_layer = nn.Linear(embed_dim, vocab_size)
+        
+        self.dropout = nn.Dropout(0.1)
+        
+    def forward(self, input_ids, attention_mask=None):
+        # 1. Получаем эмбеддинги
+        x = self.embedding(input_ids)  # [batch, seq_len, embed_dim]
+        x = x + self.pos_encoding[:, :x.size(1), :]
+        x = self.dropout(x)
         
-        # ЕДИНЫЙ СИСТЕМНЫЙ ПРОМПТ
-        self.system_prompt = f"""Ты - {AI_NAME}, нейросетевой AI-ассистент от компании {COMPANY_NAME}.
-Ты создан в {CREATION_DATE} командой {', '.join(CREATORS)}.
-Ты всегда отвечаешь на русском языке, дружелюбно и профессионально.
-Ты помогаешь с любыми вопросами: наука, технологии, образование, математика.
-Ты генерируешь уникальные ответы каждый раз, не используя шаблоны.
-Ты не используешь if/else в своих ответах, только нейросетевая генерация.
+        # 2. Проходим через слои внимания
+        for attn, ffn, norm in zip(
+            self.attention_layers, self.ffn_layers, self.norm_layers
+        ):
+            # Attention
+            attn_output, _ = attn(x, x, x, key_padding_mask=~attention_mask.bool())
+            x = x + attn_output
+            x = norm(x)
+            
+            # FFN
+            ffn_output = ffn(x)
+            x = x + ffn_output
+            x = norm(x)
+        
+        # 3. Выходной слой
+        logits = self.output_layer(x)
+        
+        return logits
 
-Вопрос пользователя: """
+# ===================================================================
+# 3. ДАТАСЕТ ДЛЯ ОБУЧЕНИЯ
+# ===================================================================
+
+class ScienceDataset(Dataset):
+    """Свой датасет для обучения"""
     
-    def load_model(self):
-        with st.spinner("🧠 Загружаю нейросеть..."):
-            try:
-                from transformers import GPT2LMHeadModel, GPT2Tokenizer
-                
-                self.tokenizer = GPT2Tokenizer.from_pretrained(MODEL_NAME)
-                self.model = GPT2LMHeadModel.from_pretrained(MODEL_NAME)
-                self.model.to(self.device)
-                self.model.eval()
-                
-                self.generator = pipeline(
-                    'text-generation',
-                    model=self.model,
-                    tokenizer=self.tokenizer,
-                    device=0 if torch.cuda.is_available() else -1,
-                    max_length=400,
-                    temperature=0.85,
-                    top_p=0.95,
-                    do_sample=True,
-                    repetition_penalty=1.2,
-                    pad_token_id=self.tokenizer.eos_token_id
-                )
-                
-                self.is_loaded = True
-                return True
-            except Exception as e:
-                st.error(f"Ошибка загрузки: {e}")
-                return False
+    def __init__(self, articles, tokenizer, max_length=256):
+        self.articles = articles
+        self.tokenizer = tokenizer
+        self.max_length = max_length
+        
+    def __len__(self):
+        return len(self.articles)
     
-    def generate(self, query):
-        """ГЕНЕРИРУЕТ ВСЕГДА, БЕЗ IF/ELSE"""
-        # Очищаем запрос
-        clean_q = self.clean_query(query)
+    def __getitem__(self, idx):
+        article = self.articles[idx]
+        text = f"{article['title']}. {article['text']}"
         
-        if not self.is_loaded:
-            return f"Я {AI_NAME} от {COMPANY_NAME}. Нейросеть временно недоступна. Попробуйте позже. 🧠"
+        # Токенизация
+        encoding = self.tokenizer(
+            text,
+            truncation=True,
+            padding='max_length',
+            max_length=self.max_length,
+            return_tensors='pt'
+        )
         
-        try:
-            # Формируем промпт
-            prompt = self.system_prompt + clean_q
+        return {
+            'input_ids': encoding['input_ids'].squeeze(),
+            'attention_mask': encoding['attention_mask'].squeeze(),
+            'labels': encoding['input_ids'].squeeze()  # Для обучения
+        }
+
+# ===================================================================
+# 4. ОБУЧЕНИЕ НЕЙРОСЕТИ
+# ===================================================================
+
+def train_model(model, dataloader, epochs=10, lr=1e-4):
+    """Обучение своей нейросети"""
+    
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    model = model.to(device)
+    
+    optimizer = torch.optim.AdamW(model.parameters(), lr=lr)
+    criterion = nn.CrossEntropyLoss(ignore_index=0)  # ignore padding
+    
+    losses = []
+    
+    for epoch in range(epochs):
+        total_loss = 0
+        progress_bar = st.progress(0)
+        status_text = st.empty()
+        
+        for i, batch in enumerate(dataloader):
+            input_ids = batch['input_ids'].to(device)
+            attention_mask = batch['attention_mask'].to(device)
+            labels = batch['labels'].to(device)
             
-            # Генерируем ответ
-            response = self.generator(
-                prompt,
-                max_new_tokens=300,
-                temperature=0.85,
-                top_p=0.95,
-                do_sample=True,
-                repetition_penalty=1.2
-            )[0]['generated_text']
+            # Forward
+            optimizer.zero_grad()
+            logits = model(input_ids, attention_mask)
             
-            # Убираем промпт
-            response = response.replace(prompt, "").strip()
+            # Вычисляем loss
+            loss = criterion(
+                logits.view(-1, logits.size(-1)),
+                labels.view(-1)
+            )
             
-            # Если ответ пустой - генерируем общий
-            if len(response) < 10:
-                return f"Я {AI_NAME} от {COMPANY_NAME}. Я помогаю с научными вопросами, технологиями и образованием. Что именно вас интересует? 🧠"
+            # Backward
+            loss.backward()
+            torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+            optimizer.step()
             
-            return response
+            total_loss += loss.item()
             
-        except Exception as e:
-            return f"Я {AI_NAME}. Произошла ошибка при генерации. Попробуйте переформулировать вопрос. 🧠"
+            # Обновляем прогресс
+            progress = (i + 1) / len(dataloader)
+            progress_bar.progress((epoch + progress) / epochs)
+            status_text.text(
+                f"Эпоха {epoch+1}/{epochs}, "
+                f"Батч {i+1}/{len(dataloader)}, "
+                f"Loss: {loss.item():.4f}"
+            )
+        
+        avg_loss = total_loss / len(dataloader)
+        losses.append(avg_loss)
+        st.write(f"✅ Эпоха {epoch+1}: Средний Loss = {avg_loss:.4f}")
     
-    def clean_query(self, query):
-        """Очистка от спама"""
-        query = re.sub(r'http[s]?://\S+', '', query)
-        query = re.sub(r'\S+@\S+', '', query)
-        query = re.sub(r'\+7\s*\(?\d{3}\)?\s*\d{3}\s*\d{2}\s*\d{2}', '', query)
-        query = re.sub(r'[^\w\s\.\?\!,;:-]', ' ', query)
-        query = ' '.join(query.split())
+    return model, losses
+
+# ===================================================================
+# 5. ГЕНЕРАЦИЯ ОТВЕТОВ
+# ===================================================================
+
+def generate_answer(model, tokenizer, query, max_length=150):
+    """Генерация ответа своей нейросетью"""
+    
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    model.eval()
+    
+    with torch.no_grad():
+        # Токенизируем запрос
+        encoding = tokenizer(
+            query,
+            truncation=True,
+            padding='max_length',
+            max_length=100,
+            return_tensors='pt'
+        )
+        
+        input_ids = encoding['input_ids'].to(device)
+        attention_mask = encoding['attention_mask'].to(device)
+        
+        # Генерируем ответ
+        generated = input_ids.clone()
         
-        if len(query) > 300:
-            sentences = re.split(r'[.!?]', query)
-            query = '. '.join([s for s in sentences[:2] if len(s) > 10]) + '.'
+        for _ in range(max_length):
+            logits = model(generated, attention_mask)
+            
+            # Берем последний токен
+            next_token_logits = logits[:, -1, :]
+            next_token_probs = F.softmax(next_token_logits, dim=-1)
+            
+            # Выбираем токен
+            next_token = torch.multinomial(next_token_probs, num_samples=1)
+            
+            # Добавляем к последовательности
+            generated = torch.cat([generated, next_token], dim=1)
+            
+            # Если сгенерирован токен конца
+            if next_token.item() == tokenizer.eos_token_id:
+                break
+        
+        # Декодируем
+        response = tokenizer.decode(generated[0], skip_special_tokens=True)
         
-        return query.strip() if query else "Расскажи о себе"
+        # Убираем запрос из ответа
+        response = response.replace(query, "").strip()
+        
+        return response if response else "Извините, нейросеть не сгенерировала ответ."
 
 # ===================================================================
-# 3. ЗАГРУЗКА СТАТЕЙ (ДЛЯ КОНТЕКСТА)
+# 6. ЗАГРУЗКА ДАННЫХ
 # ===================================================================
 
 @st.cache_resource
 def load_science_articles():
-    if os.path.exists("science_articles.pkl"):
-        with open("science_articles.pkl", 'rb') as f:
+    articles_file = "science_articles.pkl"
+    
+    if os.path.exists(articles_file):
+        with open(articles_file, 'rb') as f:
             return pickle.load(f)
     
     with st.spinner("📚 Загружаю научные статьи..."):
@@ -164,13 +283,14 @@ def load_science_articles():
                 articles.append({
                     "id": i,
                     "title": title[:200],
-                    "text": text[:2000],
+                    "text": text[:1000],
                     "source": "ru_science"
                 })
-            with open("science_articles.pkl", 'wb') as f:
+            with open(articles_file, 'wb') as f:
                 pickle.dump(articles, f)
             return articles
-        except:
+        except Exception as e:
+            st.error(f"Ошибка: {e}")
             return []
 
 @st.cache_resource
@@ -180,149 +300,97 @@ def load_embedder():
     except:
         return None
 
-@st.cache_resource
-def create_embeddings(_articles, _embedder):
-    if os.path.exists("science_embeddings.npy"):
-        return np.load("science_embeddings.npy")
-    if not _articles or _embedder is None:
-        return np.array([])
-    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=64)
-    np.save("science_embeddings.npy", embeddings)
-    return embeddings
-
-def search_articles(query, _articles, _embeddings, _embedder):
-    if not _articles or len(_embeddings) == 0 or _embedder is None:
-        return []
-    try:
-        query_vector = _embedder.encode([query], normalize_embeddings=True)[0]
-        scores = _embeddings @ query_vector
-        top_indices = np.argsort(-scores)[:2]
-        results = []
-        for idx in top_indices:
-            score = float(scores[int(idx)])
-            if score > 0.15:
-                article = _articles[int(idx)]
-                results.append({"title": article['title'], "score": score, "text": article['text'][:500]})
-        return results
-    except:
-        return []
-
-# ===================================================================
-# 4. ОСНОВНОЙ КЛАСС
-# ===================================================================
-
-class OpenAirAI:
-    def __init__(self):
-        self.name = AI_NAME
-        self.company = COMPANY_NAME
-        self.creators = CREATORS
-        self.chatbot = NeuralChatbot()
-        self.is_ready = False
-        
-    def initialize(self):
-        self.is_ready = self.chatbot.load_model()
-        return self.is_ready
-    
-    def generate_answer(self, query):
-        """ВСЕГДА ГЕНЕРИРУЕТ ЧЕРЕЗ НЕЙРОСЕТЬ"""
-        return self.chatbot.generate(query)
-
 # ===================================================================
-# 5. ИНТЕРФЕЙС
+# 7. ИНТЕРФЕЙС
 # ===================================================================
 
-# Загрузка
+# Загрузка данных
 articles = load_science_articles()
-embedder = load_embedder()
-embeddings = create_embeddings(articles, embedder)
 
-# Инициализация AI
-if 'ai' not in st.session_state:
-    st.session_state.ai = OpenAirAI()
-    st.session_state.ai.initialize()
+st.title(f"🧠 {AI_NAME} - Своя нейросеть на PyTorch")
+st.markdown(f"**{AI_NAME}** от **{COMPANY_NAME}** | Обучаем на **{SCIENCE_DATASET}**")
 
-ai = st.session_state.ai
+# Информация о модели
+st.info(f"📊 **Данные:** {len(articles)} статей | **Размер модели:** 256 эмбеддингов | **Слои:** 4 Transformer")
 
-# История чата
-if "messages" not in st.session_state:
-    st.session_state.messages = []
-    # ВСЕГДА ГЕНЕРИРУЕТСЯ НЕЙРОСЕТЬЮ
-    greeting = ai.generate_answer("Привет! Представься и расскажи о себе за 1-2 предложения")
-    st.session_state.messages.append({"role": "assistant", "content": greeting})
+# Кнопка обучения
+if st.button("🚀 Обучить нейросеть с нуля"):
+    if not articles:
+        st.error("Нет данных для обучения!")
+    else:
+        # Загружаем токенизатор
+        tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+        tokenizer.pad_token = tokenizer.eos_token
+        
+        # Создаем датасет
+        dataset = ScienceDataset(articles, tokenizer, MAX_LENGTH)
+        dataloader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True)
+        
+        # Создаем модель
+        vocab_size = len(tokenizer)
+        model = SimpleTransformer(
+            vocab_size=vocab_size,
+            embed_dim=256,
+            num_heads=8,
+            num_layers=4,
+            max_length=MAX_LENGTH
+        )
+        
+        # Обучаем
+        st.write("🧠 **Начинаем обучение...**")
+        trained_model, losses = train_model(
+            model, 
+            dataloader, 
+            epochs=EPOCHS,
+            lr=LEARNING_RATE
+        )
+        
+        # Сохраняем модель
+        torch.save(trained_model.state_dict(), "openairai_model.pth")
+        st.success(f"✅ Модель сохранена! (потери: {losses[-1]:.4f})")
+        
+        st.session_state.model = trained_model
+        st.session_state.tokenizer = tokenizer
 
-# --- БОКОВАЯ ПАНЕЛЬ ---
-with st.sidebar:
-    st.image("https://cdn-icons-png.flaticon.com/512/4248/4248455.png", width=80)
-    st.title(f"🧠 {AI_NAME}")
-    
-    st.markdown(f"""
-    **{ai.name}** | {CREATION_DATE}
-    
-    **Компания:** {ai.company}
-    **Разработчики:** {', '.join(ai.creators)}
-    
-    ---
-    **🔗 Ссылки:**
-    [🌐 Сайт]({WEBSITE})
-    [🤗 Hugging Face]({HUGGINGFACE})
+# Проверка модели
+if "model" in st.session_state:
+    model = st.session_state.model
+    tokenizer = st.session_state.tokenizer
     
-    ---
-    **📊 Статистика:**
-    - Статей: {len(articles)}
-    - Сообщений: {len(st.session_state.messages)}
-    - Модель: {MODEL_NAME.split("/")[-1]}
-    """)
+    st.success("✅ Модель загружена и готова к использованию!")
     
-    # Кнопки уп��авления
-    if st.button("🔄 Новое приветствие"):
-        new_greeting = ai.generate_answer("Привет! Представься заново, но по-другому")
-        if st.session_state.messages:
-            st.session_state.messages[0] = {"role": "assistant", "content": new_greeting}
-            st.rerun()
+    # Поле для вопроса
+    query = st.text_input("🔍 Задайте вопрос нейросети:", placeholder="Например: Что такое наука?")
     
-    if st.button("🗑️ Очистить чат"):
-        st.session_state.messages = []
-        greeting = ai.generate_answer("Привет! Представься кратко")
-        st.session_state.messages.append({"role": "assistant", "content": greeting})
-        st.rerun()
-
-# --- ОСНОВНАЯ ЧАСТЬ ---
-st.title(f"🧠 {AI_NAME} - Нейросетевой AI-ассистент")
-st.markdown(f"**{AI_NAME}** от **{COMPANY_NAME}** | 💡 Ответы генерируются нейросетью без шаблонов")
-
-# Отображение сообщений
-for message in st.session_state.messages:
-    with st.chat_message(message["role"]):
-        st.markdown(message["content"])
-
-# Поле ввода
-if prompt := st.chat_input("Задайте любой вопрос..."):
-    # Добавляем сообщение пользователя
-    st.session_state.messages.append({"role": "user", "content": prompt})
-    with st.chat_message("user"):
-        st.markdown(prompt)
+    if query:
+        with st.spinner("🧠 Нейросеть думает..."):
+            response = generate_answer(model, tokenizer, query)
+            st.markdown(f"**🤖 Ответ:** {response}")
+else:
+    st.warning("⚠️ Модель ещё не обучена. Нажмите кнопку выше для обучения.")
     
-    # Генерация ответа
-    with st.chat_message("assistant"):
-        with st.spinner("🧠 Нейросеть генерирует ответ..."):
-            # ВСЕГДА ГЕНЕРИРУЕМ ЧЕРЕЗ НЕЙРОСЕТЬ
-            response = ai.generate_answer(prompt)
-            
-            # Ищем статьи для контекста (если есть)
-            articles_context = search_articles(prompt, articles, embeddings, embedder)
-            if articles_context and len(response) < 100:
-                # Добавляем статьи, НО через нейросеть
-                context_prompt = f"Добавь в ответ ссылки на эти статьи: {', '.join([a['title'] for a in articles_context])}"
-                enhanced_response = ai.generate_answer(context_prompt)
-                if len(enhanced_response) > len(response):
-                    response = enhanced_response
-            
-            st.markdown(response)
-            st.session_state.messages.append({"role": "assistant", "content": response})
-    
-    st.rerun()
+    # Показываем пример обучения
+    with st.expander("📖 Как это работает?"):
+        st.markdown("""
+        **Своя нейросеть на PyTorch:**
+        
+        1. **Архитектура:** Transformer (4 слоя внимания)
+        2. **Размер:** 256 эмбеддингов
+        3. **Обучение:** на научных статьях
+        4. **Генерация:** пошаговая
+        
+        **Преимущества:**
+        - Полный контроль над моделью
+        - Можно дообучать на любых данных
+        - Не зависит от сторонних API
+        - Бесплатно
+        
+        **Недостатки:**
+        - Требует GPU для быстрого обучения
+        - Меньше, чем большие модели
+        - Нужно много данных
+        """)
 
 # --- ПОДВАЛ ---
 st.divider()
-st.caption(f"🧠 {AI_NAME} от {COMPANY_NAME} | Создан в {CREATION_DATE} | Генеративная нейросеть")
+st.caption(f"🧠 {AI_NAME} от {COMPANY_NAME} | Создан в {CREATION_DATE} | Своя нейросеть на PyTorch")