Optimize app.py for cached loading

app.py

@@ -19,39 +19,74 @@ from bs4 import BeautifulSoup
 @st.cache_resource
 def load_data():
     # Загрузка датасета
-    data = load_dataset('Romyx/ru_QA_school_history', split='train')
-    df = pd.DataFrame(data)
+    st.info("Загрузка датасета...")
+    try:
+        data = load_dataset('Romyx/ru_QA_school_history', split='train')
+        df = pd.DataFrame(data)
+        st.success("Датасет загружен.")
+    except Exception as e:
+        st.error(f"Ошибка загрузки датасета: {e}")
+        raise e # Прерывает выполнение, если датасет не загрузился
+
+    # Предобработка сразу после загрузки
     df['Pt_question'] = df['question'].apply(preprocess_text)
     df['Pt_answer'] = df['answer'].apply(preprocess_text)
     return df
 
 @st.cache_resource
 def load_model_and_tokenizer():
-    # Загрузка предобученной модели вопрос-ответа (например, SberQuad)
-    model_name = "AlexKay/xlm-roberta-large-qa-multilingual-finedtuned-ru"  # замените на нужную модель, например, "bert-base-uncased"
-    tokenizer = AutoTokenizer.from_pretrained(model_name)
-    model = AutoModelForQuestionAnswering.from_pretrained(model_name)
+    st.info("Загрузка модели вопрос-ответа...")
+    try:
+        # Убедитесь, что это имя совпадает с именем модели, загруженной в Dockerfile
+        model_name = "AlexKay/xlm-roberta-large-qa-multilingual-finedtuned-ru"
+        tokenizer = AutoTokenizer.from_pretrained(model_name)
+        model = AutoModelForQuestionAnswering.from_pretrained(model_name)
+        st.success("Модель вопрос-ответа загружена.")
+    except Exception as e:
+        st.error(f"Ошибка загрузки модели вопрос-ответа: {e}")
+        raise e
     return tokenizer, model
 
 @st.cache_resource
 def build_vectorizer(_df):
-    combined_texts = _df['Pt_question'].tolist() + _df['Pt_answer'].tolist()
-    vectorizer = TfidfVectorizer()
-    tfidf_matrix = vectorizer.fit_transform(combined_texts)
+    st.info("Обучение TF-IDF векторайзера...")
+    try:
+        combined_texts = _df['Pt_question'].tolist() + _df['Pt_answer'].tolist()
+        vectorizer = TfidfVectorizer()
+        tfidf_matrix = vectorizer.fit_transform(combined_texts)
+        st.success("TF-IDF векторайзер обучен.")
+    except Exception as e:
+        st.error(f"Ошибка обучения TF-IDF: {e}")
+        raise e
     return vectorizer, tfidf_matrix
 
 # === Предобработка текста ===
 
-# Загрузка Spacy модели
-nlp = spacy.load('ru_core_news_lg')
-stop_words = set(stopwords.words('russian'))
-
+# Загрузка Spacy модели при запуске скрипта (не внутри @st.cache_resource, если она в образе)
+# Используем @st.cache_resource для загрузки nlp модели, чтобы она кэшировалась
+@st.cache_resource
+def load_spacy_model():
+    st.info("Загрузка SpaCy модели...")
+    try:
+        # Убедитесь, что это имя совпадает с моделью, загруженной в Dockerfile
+        nlp = spacy.load('ru_core_news_lg')
+        st.success("SpaCy модель загружена.")
+    except OSError as e:
+        st.error(f"SpaCy модель 'ru_core_news_lg' не найдена. Проверьте Dockerfile: {e}")
+        raise e
+    return nlp
+
+# Функция для получения нормальной формы слова
+# Используем кэш внутри функции для избежания повторных вызовов spaCy
+# Но для кэширования результатов между вызовами функции можно использовать кэш Streamlit или обычный словарь
+# Для простоты, кэшируем в обычном словаре, но помните, что это не персистентный кэш между перезапусками
 cache_dict = {}
 
-def get_norm_form(word):
+def get_norm_form(nlp_model, word): # Передаём nlp_model как аргумент
     if word in cache_dict:
         return cache_dict[word]
-    norm_form = nlp(word)[0].lemma_
+    # Используем переданную модель
+    norm_form = nlp_model(word)[0].lemma_
     cache_dict[word] = norm_form
     return norm_form
 
@@ -75,14 +110,19 @@ def preprocess_text(text):
     text = re.sub(r'[^\w\s]', '', text)
 
     tokens = word_tokenize(text)
-    tokens = [token for token in tokens if token not in stop_words]
-    tokens = [get_norm_form(token) for token in tokens]
+    # stop_words загружается при старте
+    stop_words_set = set(stopwords.words('russian'))
+    tokens = [token for token in tokens if token not in stop_words_set]
+    # Загружаем nlp модель из кэша Streamlit
+    nlp_model = load_spacy_model()
+    tokens = [get_norm_form(nlp_model, token) for token in tokens]
 
     words_to_remove = {"ответ", "new"}
     tokens = [token for token in tokens if token not in words_to_remove]
 
     return ' '.join(tokens)
 
+
 # === Основная функция получения ответа ===
 def get_answer_from_qa_model(user_question, df, vectorizer, tfidf_matrix, model, tokenizer):
     processed = preprocess_text(user_question)