Update app.py

app.py

@@ -18,7 +18,7 @@ import time
 from huggingface_hub import model_info
 from datetime import datetime
 
-# 1. Первым делом - настройка логирования (до всех операций)
+# 1. Настройка логирования
 logging.basicConfig(
     level=logging.INFO,
     format='%(asctime)s - %(levelname)s - %(message)s',
@@ -29,17 +29,17 @@ logging.basicConfig(
 )
 logger = logging.getLogger()
 
-# 2. Проверка загрузки модели (сразу после логирования)
+# 2. Проверка загрузки модели
 try:
     logger.info("="*50)
     logger.info("Начало принудительной проверки модели")
     test_model = SentenceTransformer(
         "cointegrated/LaBSE-en-ru",
         device='cpu',
-        cache_folder="/tmp/hf_cache_force"  # Отдельный кеш для теста
+        cache_folder="/tmp/hf_cache_force"
     )
     logger.info(f"Модель загружена. Размерность: {test_model.get_sentence_embedding_dimension()}")
-    del test_model  # Освобождаем память
+    del test_model
 except Exception as e:
     logger.critical(f"Тестовая загрузка модели провалилась: {str(e)}", exc_info=True)
     st.error("""
@@ -51,23 +51,23 @@ except Exception as e:
     """)
     raise
 
-# 3. Инициализация NLTK (после проверки модели)
+# 3. Инициализация NLTK
 nltk.download('punkt', quiet=True)
 nltk.download('stopwords', quiet=True)
 
-# 4. Остальные константы
+# 4. Константы
 XLSX_FILE_PATH = "Test_questions_from_diagnostpb (1).xlsx"
 SQLITE_DB_PATH = "knowledge_base_v1.db"
 VECTOR_DB_DIR = "vectorized_knowledge_base"
 VECTOR_DB_PATH = os.path.join(VECTOR_DB_DIR, "processed_knowledge_base_v1.db")  
 FAISS_INDEX_PATH = os.path.join(VECTOR_DB_DIR, "faiss_index.bin")
 LOG_FILE = "chat_logs.json"
-EMBEDDING_MODEL = "cointegrated/LaBSE-en-ru"  # Теперь мы уверены, что модель работает
+EMBEDDING_MODEL = "cointegrated/LaBSE-en-ru"
 
-# 5. Инициализация OpenAI (если нужно)
+# 5. Инициализация OpenAI
 openai_api_key = os.getenv('VSEGPT_API_KEY')
 if openai_api_key is None:
-    logger.error("Переменная окружения VSEGPT_API_KEY не установлена")
+    logger.error("Переменная окружения VSEGPT_API_KEY не установена")
     st.warning("Не настроен API-ключ для OpenAI")   
     raise ValueError("Переменная окружения VSEGPT_API_KEY не установена")
 
@@ -95,264 +95,203 @@ class HybridSearch:
         self._init_bm25()
     
     def _init_bm25(self):
-        """Инициализация BM25 с данными из базы"""
+        """Инициализация BM25 с подробной диагностикой"""
         try:
             logger.info(f"Инициализация BM25 для базы: {self.db_path}")
             
             # Проверка существования файла
             if not os.path.exists(self.db_path):
                 logger.error(f"Файл базы данных не существует: {self.db_path}")
+                st.error(f"Файл базы данных не найден: {self.db_path}")
                 return
                 
-            conn = get_db_connection(self.db_path)
+            # Проверка размера файла
+            db_size = os.path.getsize(self.db_path)
+            logger.info(f"Размер файла БД: {db_size} байт")
+            if db_size == 0:
+                logger.error("Файл базы данных пуст!")
+                st.error("Файл базы данных пуст!")
+                return
+
+            # Проверка прав доступа
+            try:
+                perm = oct(os.stat(self.db_path).st_mode)[-3:]
+                logger.info(f"Права доступа к файлу: {perm}")
+            except Exception as e:
+                logger.warning(f"Не удалось проверить права доступа: {str(e)}")
+
+            conn = sqlite3.connect(self.db_path)
+            conn.row_factory = sqlite3.Row
             cursor = conn.cursor()
             
-            # Проверка таблицы content
-            cursor.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='content';")
-            if not cursor.fetchone():
+            # Проверка структуры базы
+            cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
+            tables = [row[0] for row in cursor.fetchall()]
+            logger.info(f"Таблицы в базе: {tables}")
+            
+            if 'content' not in tables:
                 logger.error("Таблица 'content' не найдена в базе данных!")
+                st.error("Таблица 'content' не найдена в б��зе данных!")
                 conn.close()
                 return
             
+            # Проверка количества записей
+            cursor.execute("SELECT COUNT(*) FROM content")
+            count = cursor.fetchone()[0]
+            logger.info(f"Количество записей в content: {count}")
+            
+            if count == 0:
+                logger.error("Таблица content пуста!")
+                st.error("Таблица content пуста!")
+                conn.close()
+                return
+                
+            # Получение данных
             cursor.execute("""
                 SELECT c.id, c.chunk_text 
                 FROM content c
+                ORDER BY c.id
+                LIMIT 1000  # Ограничиваем для теста
             """)
             
             rows = cursor.fetchall()
             logger.info(f"Получено строк из БД: {len(rows)}")
             
-            if not rows:
-                logger.warning("Таблица content пуста!")
-                conn.close()
-                return
-                
-            for i, row in enumerate(rows):
+            # Тестовый вывод первых 3 записей
+            for i, row in enumerate(rows[:3]):
                 text = row['chunk_text']
                 tokens = self._preprocess_text(text)
-                
-                # Логируем первый и последний чанки для проверки
-                if i == 0 or i == len(rows) - 1:
-                    logger.info(f"Чанк #{i} (ID: {row['id']})")
-                    logger.info(f"  Оригинал: {text[:100]}{'...' if len(text) > 100 else ''}")
-                    logger.info(f"  Токены: {tokens}")
-                    logger.info(f"  Кол-во токенов: {len(tokens)}")
-                
-                self.corpus.append(tokens)
-                self.doc_ids.append(row['id'])
+                logger.info(f"Пример #{i+1} (ID: {row['id']}):")
+                logger.info(f"  Текст: {text[:100]}{'...' if len(text) > 100 else ''}")
+                logger.info(f"  Токены: {tokens[:10]}{'...' if len(tokens) > 10 else ''}")
+                logger.info(f"  Всего токенов: {len(tokens)}")
+            
+            # Обработка всех записей
+            for row in rows:
+                text = row['chunk_text']
+                tokens = self._preprocess_text(text)
+                if tokens:  # Только если есть токены после обработки
+                    self.corpus.append(tokens)
+                    self.doc_ids.append(row['id'])
             
             conn.close()
             
             if self.corpus:
+                logger.info(f"Создание индекса BM25 для {len(self.corpus)} документов")
                 self.bm25 = BM25Okapi(self.corpus)
-                logger.info(f"BM25 инициализирован! Документов: {len(self.corpus)}")
-                logger.info(f"Пример первого документа в корпусе: {self.corpus[0][:5]}...")
+                logger.info("BM25 успешно инициализирован!")
+                
+                # Тестовая проверка поиска
+                test_query = "метрология"
+                tokenized_query = self._preprocess_text(test_query)
+                if tokenized_query:
+                    scores = self.bm25.get_scores(tokenized_query)
+                    logger.info(f"Тестовый поиск по запросу '{test_query}':")
+                    logger.info(f"  Макс. оценка: {max(scores):.2f}")
+                    logger.info(f"  Мин. оценка: {min(scores):.2f}")
+                    logger.info(f"  Средняя оценка: {np.mean(scores):.2f}")
             else:
-                logger.warning("Корпус BM25 пуст после обработки!")
+                logger.error("Корпус для BM25 пуст после обработки!")
+                st.error("Не удалось подготовить данные для поиска BM25")
                 
+        except sqlite3.Error as e:
+            logger.error(f"Ошибка SQLite: {str(e)}", exc_info=True)
+            st.error(f"Ошибка базы данных: {str(e)}")
+            if 'conn' in locals():
+                conn.close()
         except Exception as e:
-            logger.error(f"Ошибка инициализации BM25: {str(e)}", exc_info=True)
+            logger.error(f"Общая ошибка инициализации BM25: {str(e)}", exc_info=True)
+            st.error(f"Ошибка инициализации поиска: {str(e)}")
+            if 'conn' in locals():
+                conn.close()
     
     def _preprocess_text(self, text):
-        """Предварительная обработка текста для BM25"""
+        """Предварительная обработка текста с улучшенной обработкой ошибок"""
         try:
-            # Логируем исходный текст для отладки
             if not text or not isinstance(text, str):
                 logger.warning(f"Получен пустой или нестроковый текст: {type(text)} - {str(text)[:50]}")
                 return []
                 
-            tokens = word_tokenize(text.lower(), language='russian')
-            filtered_tokens = [token for token in tokens if token not in self.stop_words and token.isalnum()]
+            # Удаление специальных символов и чисел
+            clean_text = re.sub(r'[^\w\s]', ' ', text)
+            clean_text = re.sub(r'\d+', '', clean_text)
+            
+            tokens = word_tokenize(clean_text.lower(), language='russian')
+            filtered_tokens = [
+                token for token in tokens 
+                if token not in self.stop_words 
+                and len(token) > 2  # Игнорируем очень короткие слова
+                and token.isalpha()  # Только буквенные токены
+            ]
+            
+            if not filtered_tokens:
+                logger.debug(f"Нет токенов после обработки в тексте: {text[:50]}...")
+                
             return filtered_tokens
         except Exception as e:
             logger.error(f"Ошибка обработки текста: {str(e)} | Текст: '{text[:50]}...'", exc_info=True)
             return []
     
     def search(self, query, top_k=5):
-        """Выполняет поиск BM25"""
+        """Выполняет поиск BM25 с улучшенной обработкой ошибок"""
         if not self.bm25:
+            logger.warning("BM25 не инициализирован, поиск невозможен")
             return []
             
-        tokenized_query = self._preprocess_text(query)
-        scores = self.bm25.get_scores(tokenized_query)
-        top_indices = np.argsort(scores)[-top_k:][::-1]
-        
-        results = []
-        conn = get_db_connection(self.db_path)
-        
-        for idx in top_indices:
-            if scores[idx] <= 0:
-                continue
+        try:
+            tokenized_query = self._preprocess_text(query)
+            if not tokenized_query:
+                logger.warning(f"Запрос '{query}' не содержит значимых токенов после обработки")
+                return []
                 
-            doc_id = self.doc_ids[idx]
-            cursor = conn.cursor()
-            cursor.execute("""
-                SELECT c.chunk_text, d.doc_type_short, d.doc_number, d.file_name
-                FROM content c
-                JOIN documents d ON c.document_id = d.id
-                WHERE c.id = ?
-            """, (doc_id,))
+            logger.info(f"Поиск BM25 по запросу: '{query}'")
+            logger.info(f"Токены запроса: {tokenized_query}")
             
-            row = cursor.fetchone()
-            if row:
-                source_parts = [
-                    str(row['doc_type_short']) if row['doc_type_short'] else None,
-                    str(row['doc_number']) if row['doc_number'] else None,
-                    str(row['file_name']) if row['file_name'] else None
-                ]
-                source = " ".join(filter(None, source_parts)) or "Неизвестный источник"
-                
-                results.append({
-                    "text": row['chunk_text'],
-                    "source": source,
-                    "score": float(scores[idx]),
-                    "type": "bm25"
-                })
-        
-        conn.close()
-        return results
-
-# Загрузка данных из XLSX
-@st.cache_data
-def load_models():
-    """Загрузка моделей с подробным логированием и обработкой ошибок"""
-    def log_model_info():
-        """Вспомогательная функция для логирования информации о модели"""
-        try:
-            info = model_info(EMBEDDING_MODEL)
-            logger.info(f"Информация о модели: размер={info.size}, обновление={info.lastModified}")
-            return True
-        except Exception as e:
-            logger.warning(f"Не удалось получить информацию о модели: {str(e)}")
-            return False
-
-    try:
-        logger.info("="*80)
-        logger.info(f"Начало загрузки модели: {EMBEDDING_MODEL}")
-        
-        # 1. Загрузка модели SentenceTransformer
-        start_time = time.time()
-        try:
-            model = SentenceTransformer(
-                EMBEDDING_MODEL,
-                device='cpu',
-                cache_folder=os.path.expanduser("~/.cache/huggingface/hub")
-            )
-            logger.info(f"Модель загружена за {time.time()-start_time:.2f} сек")
-            logger.info(f"Размерность эмбеддингов: {model.get_sentence_embedding_dimension()}")
-        except Exception as e:
-            logger.critical(f"Ошибка загрузки модели: {str(e)}")
-            raise RuntimeError("Не удалось загрузить модель") from e
-
-        # 2. Загрузка FAISS индекса
-        logger.info(f"Загрузка FAISS индекса: {FAISS_INDEX_PATH}")
-        if not os.path.exists(FAISS_INDEX_PATH):
-            error_msg = f"Индекс не найден: {FAISS_INDEX_PATH}"
-            logger.error(error_msg)
-            raise FileNotFoundError(error_msg)
-        
-        try:
-            faiss_index = faiss.read_index(FAISS_INDEX_PATH)
-            logger.info(f"Индекс загружен (размерность: {faiss_index.d}, векторов: {faiss_index.ntotal})")
-        except Exception as e:
-            logger.critical(f"Ошибка чтения индекса: {str(e)}")
-            raise RuntimeError("Неверный формат FAISS индекса") from e
-
-        # 3. Инициализация гибридного поиска (BM25)
-        logger.info(f"Инициализация гибридного поиска: {VECTOR_DB_PATH}")
-        hybrid_search = None
-        
-        if os.path.exists(VECTOR_DB_PATH):
-            db_size = os.path.getsize(VECTOR_DB_PATH)
-            last_modified = datetime.fromtimestamp(os.path.getmtime(VECTOR_DB_PATH)).strftime('%Y-%m-%d %H:%M:%S')
+            scores = self.bm25.get_scores(tokenized_query)
+            top_indices = np.argsort(scores)[-top_k:][::-1]
             
-            logger.info(f"Проверка базы для BM25:")
-            logger.info(f"  Размер файла: {db_size} байт")
-            logger.info(f"  Последнее изменение: {last_modified}")
+            results = []
+            conn = get_db_connection(self.db_path)
+            cursor = conn.cursor()
             
-            try:
-                # Проверка структуры базы
-                conn = sqlite3.connect(VECTOR_DB_PATH)
-                cursor = conn.cursor()
-                
-                # Проверка существования таблиц
-                cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
-                tables = [row[0] for row in cursor.fetchall()]
-                logger.info(f"  Таблицы в базе: {tables}")
-                
-                if 'content' in tables:
-                    cursor.execute("SELECT COUNT(*) FROM content")
-                    count = cursor.fetchone()[0]
-                    logger.info(f"  Записей в content: {count}")
+            for idx in top_indices:
+                if scores[idx] <= 0:
+                    continue
                     
-                    if count > 0:
-                        cursor.execute("SELECT chunk_text FROM content LIMIT 1")
-                        sample = cursor.fetchone()
-                        logger.info(f"  Пример текста: {sample[0][:50] if sample else 'НЕТ ДАННЫХ'}")
-                
-                conn.close()
-                
-                # Инициализация HybridSearch
-                hybrid_search = HybridSearch(VECTOR_DB_PATH)
+                doc_id = self.doc_ids[idx]
+                cursor.execute("""
+                    SELECT c.chunk_text, d.doc_type_short, d.doc_number, d.file_name
+                    FROM content c
+                    JOIN documents d ON c.document_id = d.id
+                    WHERE c.id = ?
+                """, (doc_id,))
                 
-                if hybrid_search and hybrid_search.bm25:
-                    logger.info(f"BM25 успешно инициализирован! Документов: {len(hybrid_search.corpus)}")
-                else:
-                    logger.error("Не удалось инициализировать BM25!")
+                row = cursor.fetchone()
+                if row:
+                    source_parts = [
+                        str(row['doc_type_short']) if row['doc_type_short'] else None,
+                        str(row['doc_number']) if row['doc_number'] else None,
+                        str(row['file_name']) if row['file_name'] else None
+                    ]
+                    source = " ".join(filter(None, source_parts)) or "Неизвестный источник"
                     
-            except Exception as e:
-                logger.error(f"Ошибка при проверке базы данных: {str(e)}", exc_info=True)
-                if 'conn' in locals():
-                    conn.close()
-        else:
-            logger.error(f"Файл базы данных не найден: {VECTOR_DB_PATH}")
-
-        return model, faiss_index, hybrid_search
-
-    except Exception as e:
-        logger.critical(f"Фатальная ошибка при загрузке: {str(e)}", exc_info=True)
-        st.error("""
-        Критическая ошибка инициализации системы. Проверьте:
-        1. Наличие всех файлов данных
-        2. Логи в model_loading.log
-        3. Доступ к интернету для загрузки моделей
-        """)
-        raise
-
-def run_bm25_diagnostic(hybrid_search, question, top_k=5):
-    """Отдельная функция для диагностики BM25 с явной передачей hybrid_search"""
-    try:
-        logger.info(f"Запуск диагностики BM25 для вопроса: '{question}'")
-        
-        if not hybrid_search:
-            error_msg = "Гибридный поиск (hybrid_search) не инициализирован"
-            logger.error(error_msg)
-            raise ValueError(error_msg)
-        
-        if not hybrid_search.bm25:
-            error_msg = "BM25 не был создан при инициализации HybridSearch"
-            logger.error(error_msg)
-            raise ValueError(error_msg)
-        
-        # Запуск поиска с подробным логированием
-        logger.info(f"Поиск BM25 с top_k={top_k}")
-        results = hybrid_search.search(question, top_k=top_k)
-        
-        if not results:
-            logger.info("BM25 вернул 0 результатов (возможно, низкие оценки)")
-        else:
-            logger.info(f"Найдено результатов BM25: {len(results)}")
-            for i, res in enumerate(results, 1):
-                logger.info(
-                    f"Результат #{i}: Оценка={res['score']:.2f}, "
-                    f"Тип={res.get('type', 'unknown')}, "
-                    f"Текст={res['text'][:50]}..."
-                )
+                    results.append({
+                        "text": row['chunk_text'],
+                        "source": source,
+                        "score": float(scores[idx]),
+                        "type": "bm25"
+                    })
+            
+            conn.close()
+            
+            if not results:
+                logger.info("BM25 не нашел результатов с положительной оценкой")
+            
+            return results
         
-        return results
-    except Exception as e:
-        logger.error(f"Ошибка в run_bm25_diagnostic: {str(e)}", exc_info=True)
-        raise
+        except Exception as e:
+            logger.error(f"Ошибка при выполнении поиска BM25: {str(e)}", exc_info=True)
+            return []
 
 # Подключение к SQLite базе
 def get_db_connection(db_path):
@@ -565,6 +504,15 @@ def save_log(question, answer):
     except Exception as e:
         logger.error(f"Ошибка при сохранении лога: {e}")
 
+# Загрузка данных из XLSX
+@st.cache_data
+def load_data():
+    try:
+        return pd.read_excel(XLSX_FILE_PATH)
+    except Exception as e:
+        logger.error(f"Ошибка загрузки XLSX файла: {e}")
+        return pd.DataFrame()
+
 # Поиск ответа
 def get_answer(question):
     # 1. Проверка специальных случаев
@@ -618,10 +566,10 @@ def get_answer(question):
         answer = f"🤖 Сгенерированный ответ:\n\n{gpt_answer}\n\n"
         answer += "🔍 Использованные фрагменты документов:\n\n"
         
-        # for i, res in enumerate(hybrid_results, 1):
-        #     answer += f"### Фрагмент {i} (метод: {res['type']}, оценка: {res['combined_score']:.2f})\n"
-        #     answer += f"{res['text']}\n"
-        #     answer += f"\n📚 Источник: {res['source']}\n\n"
+        for i, res in enumerate(hybrid_results, 1):
+            answer += f"### Фрагмент {i} (метод: {res['type']}, оценка: {res['combined_score']:.2f})\n"
+            answer += f"{res['text']}\n"
+            answer += f"\n📚 Источник: {res['source']}\n\n"
         
         save_log(question, answer)
         return answer