fix: Данные для классификации

src/embeddings_train.py

@@ -121,7 +121,10 @@ def train_doc2vec(texts: Iterable[str], cfg: TrainConfig) -> Doc2Vec:
 def train_glove(texts: Iterable[str], cfg: TrainConfig):
     """Обучает GloVe модель."""
     if not GLOVE_AVAILABLE:
-        raise ImportError("GloVe не установлен. Установите: pip install glove-python-binary")
+        raise ImportError(
+            "GloVe не установлен. Установите: pip install glove-python-binary\n"
+            "Или используйте альтернативу: pip install glove-python"
+        )
     
     sentences = _tokenize_corpus(texts)
     

src/streamlit_app.py

@@ -41,6 +41,17 @@ from src.classical_vectorizers import (
 )
 from src.dimensionality import SVDConfig, run_lsa, embed_2d, explained_variance_table, top_terms_dataframe
 from src.embeddings_train import TrainConfig as EmbTrainConfig, train_model as train_embeddings_model, save_model as save_embedding_model, evaluate_neighbors as eval_neighbors, cosine_similarity as eval_cosine, word_analogy as eval_analogy
+
+# Проверяем доступность GloVe
+try:
+    from glove import Glove, Corpus
+    GLOVE_AVAILABLE = True
+except ImportError:
+    try:
+        from glove_python import Glove, Corpus
+        GLOVE_AVAILABLE = True
+    except ImportError:
+        GLOVE_AVAILABLE = False
 from src.semantic_experiments import vector_arithmetic, semantic_axis, nearest_neighbors
 from src.text_preprocessing import TextPreprocessor, PreprocessingConfig, extract_meta_features, vectorize_with_classical, vectorize_with_embeddings
 from src.classical_classifiers import ClassicalClassifiers, ClassifierConfig, compare_classifiers, evaluate_classifier
@@ -512,7 +523,15 @@ def main():
                 index=0, horizontal=True,
                 help="Предобработанные = применены настройки из блока Предобработка на левой панели"
             )
-            model_type = st.selectbox("Модель", ["w2v", "fasttext", "doc2vec", "glove"], index=0)
+            # Формируем список доступных моделей
+            available_models = ["w2v", "fasttext", "doc2vec"]
+            if GLOVE_AVAILABLE:
+                available_models.append("glove")
+            model_type = st.selectbox("Модель", available_models, index=0)
+            
+            # Показываем предупреждение, если GloVe выбран, но недоступен
+            if model_type == "glove" and not GLOVE_AVAILABLE:
+                st.warning("⚠️ GloVe не установлен. Установите: `pip install glove-python-binary`. Модель не будет обучена.")
             vector_size = st.slider("Размерность", 50, 600, 300, step=50)
             window = st.slider("Окно контекста", 2, 15, 8)
             min_count = st.slider("Min count", 1, 20, 2)
@@ -532,6 +551,11 @@ def main():
             st.download_button("📥 Скачать обучающий корпус (.txt)", data=corpus_txt, file_name="training_corpus.txt", mime="text/plain")
 
         if st.button("🎓 Обучить модель", key="train_embeddings"):
+            # Проверяем доступность GloVe перед обучением
+            if model_type == "glove" and not GLOVE_AVAILABLE:
+                st.error("❌ GloVe не установлен. Установите: `pip install glove-python-binary`")
+                st.stop()
+            
             cfg = EmbTrainConfig(
                 model_type=model_type,
                 vector_size=int(vector_size),
@@ -542,10 +566,18 @@ def main():
                 dm=1 if dm == "pv-dm" else 0,
             )
             with st.spinner("Обучаем модель..."):
-                model, tt = train_embeddings_model(corpus, cfg)
-                st.session_state["emb_model"] = model
-                st.session_state["emb_train_time"] = tt
-                st.success(f"Модель обучена за {tt:.2f} с")
+                try:
+                    model, tt = train_embeddings_model(corpus, cfg)
+                    st.session_state["emb_model"] = model
+                    st.session_state["emb_train_time"] = tt
+                    st.success(f"Модель обучена за {tt:.2f} с")
+                except ImportError as e:
+                    if "GloVe" in str(e) or "glove" in str(e).lower():
+                        st.error(f"❌ GloVe не установлен. Установите: `pip install glove-python-binary`")
+                    else:
+                        st.error(f"❌ Ошибка импорта: {e}")
+                except Exception as e:
+                    st.error(f"❌ Ошибка при обучении модели: {e}")
 
         if "emb_model" in st.session_state:
             model = st.session_state["emb_model"]
@@ -594,163 +626,370 @@ def main():
     # ======== Классификация (ЛР3) ========
     with main_tabs[3]:
         st.subheader("📊 Классификация текстов")
+        st.markdown("**Лабораторная работа №3: Сравнительный анализ методов классификации текстов**")
         
-        if not texts:
-            st.warning("⚠️ Загрузите тексты для классификации.")
+        # Загрузка корпуса из ЛР1
+        st.subheader("📁 Загрузка корпуса из ЛР №1")
+        corpus_source = st.radio(
+            "Источник корпуса:",
+            ["Из загруженных данных", "Из файла к��рпуса (JSONL)"],
+            horizontal=True,
+            key="classification_corpus_source"
+        )
+        
+        classification_texts = []
+        classification_articles = []
+        
+        if corpus_source == "Из загруженных данных":
+            if not texts:
+                st.warning("⚠️ Сначала загрузите данные на главной странице или используйте корпус из файла.")
+            else:
+                classification_texts = texts
+                st.info(f"✅ Используется {len(classification_texts)} текстов из загруженных данных")
         else:
+            # Загрузка из файла корпуса
+            corpus_file_path = st.text_input(
+                "Путь к файлу корпуса (JSONL):",
+                value="data/raw_corpus.jsonl",
+                key="classification_corpus_path"
+            )
+            
+            if st.button("📂 Загрузить корпус", key="load_classification_corpus"):
+                if os.path.exists(corpus_file_path):
+                    try:
+                        from src.utils import load_jsonl
+                        classification_articles = load_jsonl(corpus_file_path)
+                        classification_texts = [article.get('text', '') for article in classification_articles if article.get('text')]
+                        st.success(f"✅ Загружено {len(classification_texts)} статей из корпуса")
+                        st.session_state["classification_articles"] = classification_articles
+                    except Exception as e:
+                        st.error(f"❌ Ошибка при загрузке корпуса: {e}")
+                else:
+                    st.error(f"❌ Файл не найден: {corpus_file_path}")
+            
+            # Используем сохраненные статьи, если они есть
+            if "classification_articles" in st.session_state and not classification_texts:
+                classification_articles = st.session_state["classification_articles"]
+                classification_texts = [article.get('text', '') for article in classification_articles if article.get('text')]
+        
+        if not classification_texts:
+            st.warning("⚠️ Загрузите корпус для классификации.")
+            st.info("💡 Используйте корпус из ЛР №1 в формате JSONL с полями: title, text, date, url, category")
+        else:
+            # Показываем информацию о корпусе
+            total_words = sum(len(text.split()) for text in classification_texts)
+            st.info(f"📊 Корпус: {len(classification_texts)} документов, ~{total_words:,} слов")
+            
             # Выбор типа задачи
+            st.subheader("🎯 Тип задачи классификации")
             task_type = st.radio(
-                "Тип задачи классификации:",
+                "Выберите тип задачи:",
                 ["Бинарная", "Многоклассовая", "Многометочная"],
-                horizontal=True
+                horizontal=True,
+                help="Бинарная: тональность (позитивные/негативные)\nМногоклассовая: категории (политика, экономика, спорт, культура)\nМногометочная: несколько категорий одновременно"
             )
             
-            # Создание разметки (упрощенная версия - пользователь должен разметить данные заранее)
-            with st.expander("ℹ️ Информация о данных", expanded=False):
-                st.info("💡 Для полноценной работы требуется размеченный датасет. Здесь показана демонстрация на синтетических данных, сгенерированных случайным образом.")
-            
-            # Генерация синтетических меток для демонстрации
-            if "labels" not in st.session_state or st.session_state.get("task_type") != task_type:
-                if task_type == "Бинарная":
-                    st.session_state["labels"] = np.random.choice([0, 1], size=len(texts))
-                elif task_type == "Многоклассовая":
-                    st.session_state["labels"] = np.random.choice([0, 1, 2, 3], size=len(texts))
-                elif task_type == "Многометочная":
-                    # Многометочная - создаем бинарные метки для каждой категории
-                    # Каждый документ ��ожет иметь несколько меток
-                    num_labels = 4
-                    st.session_state["labels"] = np.random.randint(0, 2, size=(len(texts), num_labels))
-                    st.session_state["num_labels"] = num_labels
-                st.session_state["task_type"] = task_type
-            
-            labels = st.session_state["labels"]
+            # Разметка данных
+            st.subheader("🏷️ Разметка данных")
             
-            # Предобработка
-            st.subheader("🔧 Предобработка")
-            preprocess_config = PreprocessingConfig(
-                lowercase=True,
-                remove_html=True,
-                lemmatize=False,  # Упрощенно для скорости
-                remove_stopwords=False
-            )
-            preprocessor = TextPreprocessor(preprocess_config)
-            processed_texts = preprocessor.preprocess_batch(texts[:min(100, len(texts))])  # Ограничиваем для демо
+            # Функция для автоматической разметки по тональности (бинарная)
+            def label_sentiment_binary(texts_list):
+                """Простая эвристика для определения тональности."""
+                positive_words = ['хорошо', 'отлично', 'успех', 'победа', 'рост', 'улучшение', 'развитие', 
+                                'достижение', 'прогресс', 'радость', 'счастье', 'праздник']
+                negative_words = ['плохо', 'проблема', 'кризис', 'падение', 'ухудшение', 'поражение',
+                                'ошибка', 'неудача', 'трагедия', 'катастрофа', 'война', 'конфликт']
+                
+                labels = []
+                for text in texts_list:
+                    text_lower = text.lower()
+                    pos_count = sum(1 for word in positive_words if word in text_lower)
+                    neg_count = sum(1 for word in negative_words if word in text_lower)
+                    # 0 = негативная, 1 = позитивная
+                    label = 1 if pos_count > neg_count else 0
+                    labels.append(label)
+                return np.array(labels)
             
-            # Векторизация
-            st.subheader("🧮 Векторизация")
-            vectorization_method = st.selectbox(
-                "Метод векторизации:",
-                ["tfidf", "bow"]
-            )
+            # Функция для разметки по категориям (многоклассовая)
+            def label_categories_multiclass(articles_list):
+                """Разметка по категориям из метаданных или по ключевым словам."""
+                categories_map = {
+                    'политика': 0,
+                    'экономика': 1,
+                    'спорт': 2,
+                    'культура': 3,
+                    'технологии': 4,
+                    'общество': 5
+                }
+                
+                category_keywords = {
+                    0: ['политика', 'правительство', 'президент', 'министр', 'выборы', 'парламент', 'депутат'],
+                    1: ['экономика', 'рынок', 'компания', 'бизнес', 'финансы', 'банк', 'инвестиции', 'рубль'],
+                    2: ['спорт', 'футбол', 'хоккей', 'олимпиада', 'чемпионат', 'матч', 'игрок', 'команда'],
+                    3: ['культура', 'кино', 'театр', 'музыка', 'литература', 'искусство', 'выставка', 'концерт'],
+                    4: ['технологии', 'интернет', 'компьютер', 'смартфон', 'приложение', 'цифровой', 'IT'],
+                    5: ['общество', 'люди', 'город', 'образование', 'здравоохранение', 'социальный']
+                }
+                
+                labels = []
+                for article in articles_list:
+                    # Сначала пробуем взять категорию из метаданных
+                    category = article.get('category', '').lower() if isinstance(article, dict) else ''
+                    
+                    if category and category in categories_map:
+                        labels.append(categories_map[category])
+                    else:
+                        # Определяем по ключевым словам в тексте
+                        text = (article.get('text', '') + ' ' + article.get('title', '')).lower() if isinstance(article, dict) else str(article).lower()
+                        scores = {}
+                        for cat_id, keywords in category_keywords.items():
+                            scores[cat_id] = sum(1 for kw in keywords if kw in text)
+                        
+                        if max(scores.values()) > 0:
+                            labels.append(max(scores, key=scores.get))
+                        else:
+                            labels.append(0)  # По умолчанию политика
+                
+                return np.array(labels)
             
-            if st.button("🔨 Векторизовать тексты", key="vectorize_for_classification"):
-                with st.spinner("Векторизация..."):
-                    X, vectorizer = vectorize_with_classical(
-                        processed_texts,
-                        method=vectorization_method,
-                        ngram_range=(1, 2),
-                        max_features=1000
-                    )
-                    st.session_state["X_classification"] = X
-                    st.session_state["vectorizer_classification"] = vectorizer
-                    st.success(f"Векторизовано {len(processed_texts)} текстов, размерность: {X.shape}")
+            # Функция для многометочной разметки
+            def label_categories_multilabel(articles_list):
+                """Многометочная разметка - документ может иметь несколько категорий."""
+                category_keywords = {
+                    'политика': ['политика', 'правительство', 'президент', 'министр', 'выборы'],
+                    'экономика': ['экономика', 'рынок', 'компания', 'бизнес', 'финансы'],
+                    'спорт': ['спорт', 'футбол', 'хоккей', 'олимпиада', 'чемпионат'],
+                    'культура': ['культура', 'кино', 'театр', 'музыка', 'искусство']
+                }
+                
+                labels = []
+                for article in articles_list:
+                    text = (article.get('text', '') + ' ' + article.get('title', '')).lower() if isinstance(article, dict) else str(article).lower()
+                    doc_labels = []
+                    
+                    for category, keywords in category_keywords.items():
+                        # Документ относится к категории, если содержит хотя бы одно ключевое слово
+                        if any(kw in text for kw in keywords):
+                            doc_labels.append(1)
+                        else:
+                            doc_labels.append(0)
+                    
+                    labels.append(doc_labels)
+                
+                return np.array(labels)
             
-            # Классификация
-            if "X_classification" in st.session_state:
-                X = st.session_state["X_classification"]
-                y = labels[:len(processed_texts)]
+            # Выполняем разметку
+            if "classification_labels" not in st.session_state or st.session_state.get("classification_task_type") != task_type:
+                with st.spinner("Выполняется разметка данных..."):
+                    if task_type == "Бинарная":
+                        labels = label_sentiment_binary(classification_texts)
+                        st.session_state["classification_labels"] = labels
+                        st.session_state["classification_task_type"] = task_type
+                    elif task_type == "Многоклассовая":
+                        labels = label_categories_multiclass(classification_articles if classification_articles else classification_texts)
+                        st.session_state["classification_labels"] = labels
+                        st.session_state["classification_task_type"] = task_type
+                    elif task_type == "Многометочная":
+                        labels = label_categories_multilabel(classification_articles if classification_articles else classification_texts)
+                        st.session_state["classification_labels"] = labels
+                        st.session_state["classification_task_type"] = task_type
+                        st.session_state["num_labels"] = labels.shape[1] if len(labels.shape) > 1 else 4
                 
-                # Разделение на train/test
-                from sklearn.model_selection import train_test_split
-                # Для multilabel stratify не поддерживается напрямую
-                if task_type == "Многометочная":
-                    X_train, X_test, y_train, y_test = train_test_split(
-                        X, y, test_size=0.2, random_state=42
-                    )
+                # Показываем статистику разметки
+                if task_type == "Бинарная":
+                    unique, counts = np.unique(labels, return_counts=True)
+                    st.success(f"✅ Разметка завершена: {dict(zip(['Негативные', 'Позитивные'], counts))}")
+                elif task_type == "Многоклассовая":
+                    unique, counts = np.unique(labels, return_counts=True)
+                    category_names = ['Политика', 'Экономика', 'Спорт', 'Культура', 'Технологии', 'Общество']
+                    dist = {category_names[i] if i < len(category_names) else f'Класс {i}': count 
+                           for i, count in zip(unique, counts)}
+                    st.success(f"✅ Разметка завершена. Распределение: {dist}")
                 else:
-                    X_train, X_test, y_train, y_test = train_test_split(
-                        X, y, test_size=0.2, random_state=42, stratify=y
-                    )
+                    # Многометочная
+                    category_names = ['Политика', 'Экономика', 'Спорт', 'Культура']
+                    if len(labels.shape) > 1:
+                        counts = labels.sum(axis=0)
+                        dist = {name: int(count) for name, count in zip(category_names[:len(counts)], counts)}
+                        st.success(f"✅ Разметка завершена. Документов по категориям: {dist}")
+            
+            labels = st.session_state.get("classification_labels", np.array([]))
+            
+            if len(labels) == 0:
+                st.warning("⚠️ Разметка не выполнена. Пожалуйста, дождитесь завершения разметки.")
+            else:
+                # Предобработка
+                st.subheader("🔧 Предобработка текстов")
+                max_docs = st.slider(
+                    "Максимальное количество документов для обработки:",
+                    min_value=100,
+                    max_value=min(10000, len(classification_texts)),
+                    value=min(1000, len(classification_texts)),
+                    step=100,
+                    help="Для ускорения можно ограничить количество документов"
+                )
                 
-                st.subheader("🎯 Обучение классификаторов")
-                selected_models = st.multiselect(
-                    "Выберите модели:",
-                    ["Logistic Regression", "SVM", "Random Forest"],
-                    default=["Logistic Regression", "Random Forest"]
+                preprocess_config = PreprocessingConfig(
+                    lowercase=True,
+                    remove_html=True,
+                    lemmatize=st.checkbox("Использовать лемматизацию", value=False, help="Замедляет обработку, но улучшает качество"),
+                    remove_stopwords=st.checkbox("Удалять стоп-слова", value=False)
                 )
+                preprocessor = TextPreprocessor(preprocess_config)
                 
-                if st.button("🚀 Обучить модели", key="train_classifiers"):
-                    configs = []
-                    if "Logistic Regression" in selected_models:
-                        configs.append(ClassifierConfig(name="Logistic Regression", model_type="lr"))
-                    if "SVM" in selected_models:
-                        configs.append(ClassifierConfig(name="SVM", model_type="svm", params={"kernel": "linear"}))
-                    if "Random Forest" in selected_models:
-                        configs.append(ClassifierConfig(name="Random Forest", model_type="rf"))
+                if st.button("🔄 Выполнить предобработку", key="preprocess_classification"):
+                    with st.spinner(f"Обрабатываем {max_docs} документов..."):
+                        processed_texts = preprocessor.preprocess_batch(classification_texts[:max_docs])
+                        st.session_state["processed_classification_texts"] = processed_texts
+                        st.session_state["classification_max_docs"] = max_docs
+                        st.success(f"✅ Обработано {len(processed_texts)} документов")
+                
+                # Используем сохраненные обработанные тексты
+                if "processed_classification_texts" in st.session_state:
+                    processed_texts = st.session_state["processed_classification_texts"]
+                    max_docs_used = st.session_state.get("classification_max_docs", len(processed_texts))
+                    labels_used = labels[:max_docs_used]
+                    
+                    # Векторизация
+                    st.subheader("🧮 Векторизация")
+                    vectorization_method = st.selectbox(
+                        "Метод векторизации:",
+                        ["tfidf", "bow"],
+                        help="TF-IDF: учитывает важность терминов\nBoW: простой подсчет частот"
+                    )
+                    
+                    ngram_max = st.number_input("Максимальный n-gram", 1, 3, 2, help="1=униграммы, 2=биграммы, 3=триграммы")
+                    max_features = st.number_input("Максимальное количество признаков", 100, 10000, 1000, step=100)
+                    
+                    if st.button("🔨 Векторизовать тексты", key="vectorize_for_classification"):
+                        with st.spinner("Векторизация..."):
+                            X, vectorizer = vectorize_with_classical(
+                                processed_texts,
+                                method=vectorization_method,
+                                ngram_range=(1, ngram_max),
+                                max_features=max_features
+                            )
+                            st.session_state["X_classification"] = X
+                            st.session_state["vectorizer_classification"] = vectorizer
+                            st.success(f"✅ Векторизовано {len(processed_texts)} текстов, размерность: {X.shape}")
+                    
+                    # Классификация
+                    if "X_classification" in st.session_state:
+                        X = st.session_state["X_classification"]
+                        y = labels_used
                     
-                    with st.spinner("Обучение моделей..."):
-                        # Определяем тип задачи
+                        # Разделение на train/validation/test (70/15/15)
+                        from sklearn.model_selection import train_test_split
+                        
+                        # Сначала разделяем на train (70%) и temp (30%)
+                        if task_type == "Многометочная":
+                            X_train, X_temp, y_train, y_temp = train_test_split(
+                                X, y, test_size=0.3, random_state=42
+                            )
+                        else:
+                            X_train, X_temp, y_train, y_temp = train_test_split(
+                                X, y, test_size=0.3, random_state=42, stratify=y
+                            )
+                        
+                        # Затем temp разделяем на validation (15%) и test (15%)
                         if task_type == "Многометочная":
-                            task_type_str = "multilabel"
-                        elif task_type == "Многоклассовая":
-                            task_type_str = "multiclass"
+                            X_val, X_test, y_val, y_test = train_test_split(
+                                X_temp, y_temp, test_size=0.5, random_state=42
+                            )
                         else:
-                            task_type_str = "binary"
+                            X_val, X_test, y_val, y_test = train_test_split(
+                                X_temp, y_temp, test_size=0.5, random_state=42, stratify=y_temp
+                            )
+                        
+                        # Показываем статистику разделения
+                        st.subheader("📊 Разделение данных")
+                        col1, col2, col3 = st.columns(3)
+                        with col1:
+                            st.metric("Обучающая выборка", f"{len(X_train)} ({len(X_train)/len(X)*100:.1f}%)")
+                        with col2:
+                            st.metric("Валидационная выборка", f"{len(X_val)} ({len(X_val)/len(X)*100:.1f}%)")
+                        with col3:
+                            st.metric("Тестовая выборка", f"{len(X_test)} ({len(X_test)/len(X)*100:.1f}%)")
                         
-                        results_df = compare_classifiers(
-                            X_train, y_train, X_test, y_test,
-                            configs,
-                            task_type=task_type_str
+                        st.subheader("🎯 Обучение классификаторов")
+                        selected_models = st.multiselect(
+                            "Выберите модели:",
+                            ["Logistic Regression", "SVM", "Random Forest"],
+                            default=["Logistic Regression", "Random Forest"]
                         )
-                        st.session_state["classification_results"] = results_df
-                
-                if "classification_results" in st.session_state:
-                    st.subheader("📊 Результаты классификации")
-                    st.dataframe(st.session_state["classification_results"], use_container_width=True)
-                    
-                    # Важность признаков
-                    if "vectorizer_classification" in st.session_state and "X_classification" in st.session_state:
-                        st.subheader("🔍 Важные слова")
-                        vectorizer = st.session_state["vectorizer_classification"]
-                        if "Logistic Regression" in selected_models:
-                            # Создаем простую модель для демонстрации
-                            from sklearn.linear_model import LogisticRegression
-                            from sklearn.multioutput import MultiOutputClassifier
-                            
-                            # Получаем данные из session_state
-                            X_full = st.session_state["X_classification"]
-                            y_full = labels[:len(processed_texts)]
-                            
-                            # Для multilabel используем MultiOutputClassifier
-                            if task_type == "Многометочная":
-                                # Проверяем, что y_full - это 2D массив
-                                if len(y_full.shape) == 1:
-                                    y_full = y_full.reshape(-1, 1)
-                                # Используем только часть данных для быстрой демонстрации
-                                X_demo = X_full[:min(100, len(X_full))]
-                                y_demo = y_full[:min(100, len(y_full))]
-                                model = MultiOutputClassifier(LogisticRegression(max_iter=1000, random_state=42))
-                            else:
-                                # Для бинарной и многоклассовой классификации используем обычную модель
-                                # Убеждаемся, что y_full - это 1D массив
-                                if len(y_full.shape) > 1:
-                                    y_full = y_full.flatten() if y_full.shape[1] == 1 else y_full.argmax(axis=1)
-                                # Используем только часть данных для быстрой демонстрации
-                                X_demo = X_full[:min(100, len(X_full))]
-                                y_demo = y_full[:min(100, len(y_full))]
-                                model = LogisticRegression(max_iter=1000, random_state=42)
+                        
+                        if st.button("🚀 Обучить модели", key="train_classifiers"):
+                            configs = []
+                            if "Logistic Regression" in selected_models:
+                                configs.append(ClassifierConfig(name="Logistic Regression", model_type="lr"))
+                            if "SVM" in selected_models:
+                                configs.append(ClassifierConfig(name="SVM", model_type="svm", params={"kernel": "linear"}))
+                            if "Random Forest" in selected_models:
+                                configs.append(ClassifierConfig(name="Random Forest", model_type="rf"))
                             
-                            try:
-                                model.fit(X_demo, y_demo)
-                                # Для multilabel берем первый классификатор
+                            with st.spinner("Обучение моделей..."):
+                                # Определяем тип задачи
                                 if task_type == "Многометочная":
-                                    base_model = model.estimators_[0] if hasattr(model, 'estimators_') and len(model.estimators_) > 0 else model
+                                    task_type_str = "multilabel"
+                                elif task_type == "Многоклассовая":
+                                    task_type_str = "multiclass"
                                 else:
-                                    base_model = model
-                                important_words = get_tfidf_important_words(vectorizer, base_model, class_idx=0, top_k=20)
-                                st.dataframe(important_words, use_container_width=True)
-                            except Exception as e:
-                                st.warning(f"Не удалось показать важные слова: {e}")
+                                    task_type_str = "binary"
+                                
+                                results_df = compare_classifiers(
+                                    X_train, y_train, X_test, y_test,
+                                    configs,
+                                    task_type=task_type_str
+                                )
+                                st.session_state["classification_results"] = results_df
+                        
+                        if "classification_results" in st.session_state:
+                            st.subheader("📊 Результаты классификации")
+                            st.dataframe(st.session_state["classification_results"], use_container_width=True)
+                            
+                            # Важность признаков
+                            if "vectorizer_classification" in st.session_state and "X_classification" in st.session_state:
+                                st.subheader("🔍 Важные слова")
+                                vectorizer = st.session_state["vectorizer_classification"]
+                                if "Logistic Regression" in selected_models:
+                                    # Создаем простую модель для демонстрации
+                                    from sklearn.linear_model import LogisticRegression
+                                    from sklearn.multioutput import MultiOutputClassifier
+                                    
+                                    # Получаем данные из session_state
+                                    X_full = st.session_state["X_classification"]
+                                    y_full = labels_used
+                                    
+                                    # Для multilabel используем MultiOutputClassifier
+                                    if task_type == "Многометочная":
+                                        # Проверяем, что y_full - это 2D массив
+                                        if len(y_full.shape) == 1:
+                                            y_full = y_full.reshape(-1, 1)
+                                        # Используем только часть данных для быстрой демонстрации
+                                        X_demo = X_full[:min(100, len(X_full))]
+                                        y_demo = y_full[:min(100, len(y_full))]
+                                        model = MultiOutputClassifier(LogisticRegression(max_iter=1000, random_state=42))
+                                    else:
+                                        # Для бинарной и многоклассовой классификации используем обычную модель
+                                        # Убеждаемся, что y_full - это 1D массив
+                                        if len(y_full.shape) > 1:
+                                            y_full = y_full.flatten() if y_full.shape[1] == 1 else y_full.argmax(axis=1)
+                                        # Используем только часть данных для быстрой демонстрации
+                                        X_demo = X_full[:min(100, len(X_full))]
+                                        y_demo = y_full[:min(100, len(y_full))]
+                                        model = LogisticRegression(max_iter=1000, random_state=42)
+                                    
+                                    try:
+                                        model.fit(X_demo, y_demo)
+                                        # Для multilabel берем первый классификатор
+                                        if task_type == "Многометочная":
+                                            base_model = model.estimators_[0] if hasattr(model, 'estimators_') and len(model.estimators_) > 0 else model
+                                        else:
+                                            base_model = model
+                                        important_words = get_tfidf_important_words(vectorizer, base_model, class_idx=0, top_k=20)
+                                        st.dataframe(important_words, use_container_width=True)
+                                    except Exception as e:
+                                        st.warning(f"Не удалось показать важные слова: {e}")
 
     # ======== Кластеризация (ЛР4) ========
     with main_tabs[4]: