Upload 6 files

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+all_books.csv filter=lfs diff=lfs merge=lfs -text
+model/book_data.csv filter=lfs diff=lfs merge=lfs -text

all_books.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:822102db8bdd23be463436a64a29e453a67c75eb37e43b57a91955187588dd04
+size 10940812

app.py

@@ -0,0 +1,228 @@
+# app_modified.py - Оптимизированная версия Streamlit-приложения
+import streamlit as st
+import pandas as pd
+import numpy as np
+import torch
+from transformers import AutoTokenizer, AutoModel
+import faiss
+import re
+import nltk
+from nltk.corpus import stopwords
+from nltk.tokenize import word_tokenize
+import os
+
+# Загрузим стоп-слова для русского языка
+try:
+    nltk.data.find('corpora/stopwords')
+except LookupError:
+    nltk.download('stopwords')
+    
+try:
+    nltk.data.find('tokenizers/punkt')
+except LookupError:
+    nltk.download('punkt')
+    
+stop_words = set(stopwords.words('russian'))
+
+# Класс для получения эмбеддингов с помощью RuBERT
+class RuBERTEmbedder:
+    def __init__(self, model_name="DeepPavlov/rubert-base-cased"):
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModel.from_pretrained(model_name)
+        self.model.eval()
+        # Используем CPU для запуска в Spaces
+        self.device = "cpu"
+        self.model.to(self.device)
+    
+    def mean_pooling(self, model_output, attention_mask):
+        """Среднее значение по токенам для получения эмбеддинга предложения"""
+        token_embeddings = model_output[0]
+        input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
+        return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)
+    
+    def get_embedding(self, text):
+        """Получение векторного представления текста"""
+        encoded_input = self.tokenizer(text, padding=True, truncation=True, max_length=512, return_tensors='pt')
+        encoded_input = {k: v.to(self.device) for k, v in encoded_input.items()}
+        
+        with torch.no_grad():
+            model_output = self.model(**encoded_input)
+        
+        embeddings = self.mean_pooling(model_output, encoded_input['attention_mask'])
+        return embeddings.cpu().numpy()[0]
+
+def preprocess_text(text):
+    """Предобработка текста: удаление специальных символов, приведение к нижнему регистру, удаление стоп-слов"""
+    if isinstance(text, str):
+        # Приведение к нижнему регистру
+        text = text.lower()
+        # Удаление специальных символов
+        text = re.sub(r'[^\w\s]', '', text)
+        # Токенизация
+        tokens = word_tokenize(text, language='russian')
+        # Удаление стоп-слов
+        filtered_tokens = [word for word in tokens if word not in stop_words]
+        # Объединение обратно в строку
+        return ' '.join(filtered_tokens)
+    return ''
+
+# Класс поисковой системы
+class BookSearchEngine:
+    def __init__(self, embedder=None):
+        self.embedder = embedder
+        self.faiss_index = None
+        self.book_data = None
+        self.embeddings = None
+    
+    def load_model(self, model_dir='model'):
+        """Загрузка модели из сохраненных файлов"""
+        try:
+            # Загружаем данные книг
+            self.book_data = pd.read_csv(f"{model_dir}/book_data.csv")
+            
+            # Загружаем эмбеддинги
+            self.embeddings = np.load(f"{model_dir}/embeddings.npy")
+            
+            # Загружаем индекс FAISS
+            self.faiss_index = faiss.read_index(f"{model_dir}/faiss_index.bin")
+            
+            return True
+        except Exception as e:
+            st.error(f"Ошибка при загрузке модели: {e}")
+            return False
+    
+    def search(self, query, k=5):
+        """Поиск книг по пользовательскому запросу"""
+        if self.embedder is None or self.faiss_index is None:
+            st.error("Поисковая система не инициализирована")
+            return []
+            
+        # Предобработка запроса
+        processed_query = preprocess_text(query)
+        
+        # Получение эмбеддинга запроса
+        query_embedding = self.embedder.get_embedding(processed_query)
+        query_embedding = query_embedding.reshape(1, -1)
+        
+        # Нормализуем вектор запроса
+        faiss.normalize_L2(query_embedding)
+        
+        # Поиск ближайших соседей
+        scores, indices = self.faiss_index.search(query_embedding, k)
+        
+        # Формирование результатов
+        results = []
+        for i, (score, idx) in enumerate(zip(scores[0], indices[0])):
+            if idx < len(self.book_data):
+                book = self.book_data.iloc[idx]
+                results.append({
+                    'rank': i + 1,
+                    'score': float(score),
+                    'title': book.get('title', 'Нет названия'),
+                    'author': book.get('author', 'Нет автора'),
+                    'annotation': book.get('annotation', 'Нет аннотации'),
+                    'page_url': book.get('page_url', '#'),
+                    'book_image_url': book.get('book_image_url', book.get('image_url', ''))
+                })
+        
+        return results
+
+# Инициализация поисковой системы
+@st.cache_resource
+def initialize_search_engine():
+    # Инициализация модели RuBERT
+    embedder = RuBERTEmbedder()
+    
+    # Создание поисковой системы
+    search_engine = BookSearchEngine(embedder)
+    
+    # Загрузка подготовленной модели
+    if search_engine.load_model():
+        st.success(f"Поисковая система загружена. Всего книг: {len(search_engine.book_data)}")
+    else:
+        st.error("Не удалось загрузить модель. Пожалуйста, убедитесь, что директория 'model' содержит необходимые файлы.")
+        st.info("Перед запуском приложения нужно выполнить предварительную обработку данных с помощью скрипта preprocess.py")
+    
+    return search_engine
+
+# Основной код приложения
+def main():
+    st.set_page_config(
+        page_title="Умный поиск книг",
+        page_icon="📚",
+        layout="wide"
+    )
+    
+    st.title("📚 Умный поиск книг")
+    st.subheader("Найдите книги, соответствующие вашему запросу")
+    
+    # Инициализация поисковой системы
+    search_engine = initialize_search_engine()
+    
+    # Основной интерфейс поиска
+    st.write("### Введите описание книги, которую вы ищете")
+    
+    col1, col2 = st.columns([3, 1])
+    
+    with col1:
+        query = st.text_area("Описание книги:", height=150)
+    
+    with col2:
+        num_results = st.slider("Количество результатов:", min_value=1, max_value=20, value=5)
+        search_button = st.button("🔍 Искать", type="primary")
+    
+    # Если нажата кнопка поиска
+    if search_button:
+        if query:
+            with st.spinner("Ищем подходящие книги..."):
+                results = search_engine.search(query, k=num_results)
+            
+            if results:
+                st.write(f"### Найдено {len(results)} подходящих книг:")
+                
+                for i, result in enumerate(results):
+                    col_image, col_content, col_score = st.columns([1, 2, 1])
+                    
+                    with col_image:
+                        if 'book_image_url' in result and result['book_image_url']:
+                            try:
+                                st.image(result['book_image_url'], width=150)
+                            except Exception:
+                                st.write("Изображение недоступно")
+                    
+                    with col_content:
+                        if 'page_url' in result and result['page_url']:
+                            st.markdown(f"#### [{i+1}. {result['title']}]({result['page_url']})")
+                        else:
+                            st.markdown(f"#### {i+1}. {result['title']}")
+                        st.write(f"**Автор:** {result['author']}")
+                        with st.expander("Показать аннотацию"):
+                            st.write(result['annotation'])
+                    
+                    with col_score:
+                        st.metric(
+                            "Релевантность", 
+                            f"{result['score']:.2f}", 
+                            delta=None
+                        )
+                    
+                    st.divider()
+            else:
+                st.info("К сожалению, подходящих книг не найдено.")
+        else:
+            st.warning("Пожалуйста, введите описание книги для поиска.")
+    
+    st.markdown("---")
+    st.markdown("### О проекте")
+    st.write("""
+    Этот сервис позволяет искать книги по их описанию с использованием семантиче��кой близости. 
+    Система анализирует смысл вашего запроса и находит книги с наиболее подходящими аннотациями.
+    
+    **Технологии:**
+    - RuBERT для создания векторных представлений текста
+    - FAISS для быстрого поиска ближайших соседей
+    - Streamlit для веб-интерфейса
+    """)
+
+if __name__ == "__main__":
+    main()

model/book_data.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9b0b05dfb2ae1360e81a8d3505de2f0494b758aff5b2771732499c8c841a3989
+size 18740967

model/embeddings.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:67120e2811a0d7624613267bb99e6f663bfcd18b6121caee020966bf2da35657
+size 17126528

model/faiss_index.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6527eab896450d47e13be2af9bc34d78eb52470175221c984644c218bffe6300
+size 17126445

preproc.py

@@ -0,0 +1,185 @@
+"""
+preprocess.py - Скрипт для предварительной обработки датасета книг
+и создания векторных представлений для поисковой системы
+"""
+
+import os
+import pandas as pd
+import numpy as np
+import torch
+from transformers import AutoTokenizer, AutoModel
+import faiss
+import re
+import nltk
+from nltk.corpus import stopwords
+from nltk.tokenize import word_tokenize
+import argparse
+from tqdm import tqdm
+import nltk
+nltk.download('punkt')
+nltk.download('stopwords')
+nltk.download('punkt_tab')
+
+# Загрузим стоп-слова для русского языка
+try:
+    nltk.data.find('corpora/stopwords')
+except LookupError:
+    nltk.download('stopwords')
+    
+try:
+    nltk.data.find('tokenizers/punkt')
+except LookupError:
+    nltk.download('punkt')
+    
+stop_words = set(stopwords.words('russian'))
+
+# Класс для получения эмбеддингов с помощью RuBERT
+class RuBERTEmbedder:
+    def __init__(self, model_name="DeepPavlov/rubert-base-cased"):
+        print(f"Загрузка модели {model_name}...")
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModel.from_pretrained(model_name)
+        self.model.eval()
+        # Используем GPU если доступен, иначе CPU
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"Используется устройство: {self.device}")
+        self.model.to(self.device)
+    
+    def mean_pooling(self, model_output, attention_mask):
+        """Среднее значение по токенам для получения эмбеддинга предложения"""
+        token_embeddings = model_output[0]
+        input_mask_expanded = attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
+        return torch.sum(token_embeddings * input_mask_expanded, 1) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)
+    
+    def get_embedding(self, text):
+        """Получение векторного представления текста"""
+        encoded_input = self.tokenizer(text, padding=True, truncation=True, max_length=512, return_tensors='pt')
+        encoded_input = {k: v.to(self.device) for k, v in encoded_input.items()}
+        
+        with torch.no_grad():
+            model_output = self.model(**encoded_input)
+        
+        embeddings = self.mean_pooling(model_output, encoded_input['attention_mask'])
+        return embeddings.cpu().numpy()[0]
+    
+    def get_embeddings_batch(self, texts, batch_size=8):
+        """Получение векторных представлений для списка текстов с использованием батчей"""
+        all_embeddings = []
+        
+        for i in tqdm(range(0, len(texts), batch_size), desc="Создание эмбеддингов"):
+            batch_texts = texts[i:i+batch_size]
+            # Обработка пустых строк
+            batch_texts = [text if text and isinstance(text, str) else " " for text in batch_texts]
+            
+            encoded_input = self.tokenizer(batch_texts, padding=True, truncation=True, max_length=512, return_tensors='pt')
+            encoded_input = {k: v.to(self.device) for k, v in encoded_input.items()}
+            
+            with torch.no_grad():
+                model_output = self.model(**encoded_input)
+            
+            embeddings = self.mean_pooling(model_output, encoded_input['attention_mask'])
+            all_embeddings.append(embeddings.cpu().numpy())
+        
+        return np.vstack(all_embeddings)
+
+def preprocess_text(text):
+    """Предобработка текста: удаление специальных символов, приведение к нижнему регистру, удаление стоп-слов"""
+    if isinstance(text, str):
+        # Приведение к нижнему регистру
+        text = text.lower()
+        # Удаление специальных символов
+        text = re.sub(r'[^\w\s]', '', text)
+        # Токенизация
+        tokens = word_tokenize(text, language='russian')
+        # Удаление стоп-слов
+        filtered_tokens = [word for word in tokens if word not in stop_words]
+        # Объединение обратно в строку
+        return ' '.join(filtered_tokens)
+    return ''
+
+def prepare_data(input_file, output_dir="model", annotation_column="annotation", title_column="title", 
+                author_column="author", image_url_column="image_url", page_url_column="page_url", sample_size=None):
+    """Подготовка данных для поисковой системы"""
+    # Создание выходной директории, если она не существует
+    os.makedirs(output_dir, exist_ok=True)
+    
+    print(f"Загрузка данных из {input_file}...")
+    df = pd.read_csv(input_file)
+    
+    # Проверка наличия обязательной колонки с аннотацией
+    if annotation_column not in df.columns:
+        raise ValueError(f"В файле отсутствует колонка с аннотациями: {annotation_column}")
+    
+    # Очистка от записей без аннотации
+    initial_size = len(df)
+    df = df.dropna(subset=[annotation_column])
+    print(f"Удалено записей без аннотаций: {initial_size - len(df)}")
+    
+    # Если указан размер выборки, отбираем случайные записи
+    if sample_size and sample_size < len(df):
+        df = df.sample(sample_size, random_state=42)
+        print(f"Используется случайная выборка из {sample_size} записей")
+    
+    # Предобработка аннотаций
+    print("Предобработка аннотаций...")
+    df['processed_annotation'] = df[annotation_column].apply(preprocess_text)
+    
+    # Загрузка модели для векторизации
+    print("Инициализация модели для векторизации...")
+    embedder = RuBERTEmbedder()
+    
+    # Векторизация аннотаций
+    print("Векторизация аннотаций...")
+    annotations = df['processed_annotation'].tolist()
+    embeddings = embedder.get_embeddings_batch(annotations)
+    
+    # Создание индекса FAISS
+    print("Создание индекса FAISS...")
+    dimension = embeddings.shape[1]
+    index = faiss.IndexFlatIP(dimension)
+    faiss.normalize_L2(embeddings)
+    index.add(embeddings)
+    
+    # Сохранение обработанных данных и индекса
+    print(f"Сохранение данных в {output_dir}...")
+    
+    # Сохраняем только нужные колонки
+    columns_to_save = [col for col in [annotation_column, title_column, author_column, image_url_column, page_url_column, 'processed_annotation'] if col in df.columns]
+    df[columns_to_save].to_csv(f"{output_dir}/book_data.csv", index=False)
+    
+    # Сохраняем эмбеддинги
+    np.save(f"{output_dir}/embeddings.npy", embeddings)
+    
+    # Сохраняем индекс FAISS
+    faiss.write_index(index, f"{output_dir}/faiss_index.bin")
+    
+    print(f"Данные успешно обработаны и сохранены в {output_dir}")
+    print(f"Всего книг: {len(df)}")
+    return df
+
+def main():
+    parser = argparse.ArgumentParser(description='Предобработка датасета книг для поисковой системы')
+    parser.add_argument('--input', type=str, required=True, help='Путь к CSV файлу с данными книг')
+    parser.add_argument('--output', type=str, default='model', help='Директория для сохранения модели и данных')
+    parser.add_argument('--annotation', type=str, default='annotation', help='Имя колонки с аннотациями')
+    parser.add_argument('--title', type=str, default='title', help='Имя колонки с названиями книг')
+    parser.add_argument('--author', type=str, default='author', help='Имя колонки с авторами')
+    parser.add_argument('--image_url', type=str, default='image_url', help='Имя колонки с URL изображений')
+    parser.add_argument('--page_url', type=str, default='page_url', help='Имя колонки с URL страниц')
+    parser.add_argument('--sample', type=int, default=None, help='Размер выборки (если нужно ограничить)')
+    
+    args = parser.parse_args()
+    
+    prepare_data(
+        input_file=args.input,
+        output_dir=args.output,
+        annotation_column=args.annotation,
+        title_column=args.title,
+        author_column=args.author,
+        image_url_column=args.image_url,
+        page_url_column=args.page_url,
+        sample_size=args.sample
+    )
+
+if __name__ == "__main__":
+    main()