feat: Попытка навайбкодить 3 и 4 лабораторные

requirements.txt

@@ -23,4 +23,23 @@ umap-learn
 # glove-python-binary  # опционально
 # pymorphy2  # Несовместим с Python 3.13+
 # transformers  # Удалено по запросу пользователя
-# torch  # Удалено по запросу пользователя
+# torch  # Удалено по запросу пользователя
+
+# ЛР3 — классификация текстов
+xgboost  # опционально
+lightgbm  # опционально
+catboost  # опционально
+imbalanced-learn
+# autosklearn  # опционально, требует системные зависимости
+# tpot  # опционально
+# h2o  # опционально
+# nlpaug  # опционально
+# shap  # опционально
+# lime  # опционально
+# optuna  # опционально
+# hyperopt  # опционально
+# tensorflow  # опционально, для нейросетей
+
+# ЛР4 — кластеризация
+hdbscan
+rank-bm25

results/vectorization_metrics.csv

@@ -1,3 +1,4 @@
 Метод,N-граммы,Документов,Признаков,Ненулевых,Плотность,Время fit (с),Время transform (с),Память (MB) ~
-bow,1-2,100,1739,32653,0.187769,0.0203,0.0167,0.75
-tfidf,1-2,100,1739,32653,0.187769,0.0167,0.0138,0.75
+bow,1-5,1000,5225,957750,0.183301,0.3194,0.3208,21.92
+onehot,1-5,1000,5181,947768,0.182931,0.5572,0.3303,21.69
+tfidf,1-5,1000,5225,957750,0.183301,0.3047,0.3245,21.92

src/classical_classifiers.py

@@ -0,0 +1,400 @@
+"""
+Классические методы классификации текстов: логистическая регрессия, SVM, 
+случайный лес, градиентный бустинг, ансамбли и AutoML подходы.
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import List, Dict, Any, Optional, Tuple, Union
+
+import numpy as np
+import pandas as pd
+from sklearn.linear_model import LogisticRegression
+from sklearn.svm import SVC
+from sklearn.ensemble import RandomForestClassifier, VotingClassifier, BaggingClassifier
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.model_selection import cross_val_score, StratifiedKFold
+from sklearn.multioutput import MultiOutputClassifier
+from sklearn.multiclass import OneVsRestClassifier
+from sklearn.metrics import (
+    accuracy_score, precision_score, recall_score, f1_score,
+    roc_auc_score, classification_report, confusion_matrix,
+    precision_recall_curve, roc_curve
+)
+
+try:
+    import xgboost as xgb
+    XGBOOST_AVAILABLE = True
+except ImportError:
+    XGBOOST_AVAILABLE = False
+
+try:
+    import lightgbm as lgb
+    LIGHTGBM_AVAILABLE = True
+except ImportError:
+    LIGHTGBM_AVAILABLE = False
+
+try:
+    import catboost as cb
+    CATBOOST_AVAILABLE = True
+except ImportError:
+    CATBOOST_AVAILABLE = False
+
+try:
+    import autosklearn.classification
+    AUTOSKLEARN_AVAILABLE = True
+except ImportError:
+    AUTOSKLEARN_AVAILABLE = False
+
+try:
+    from tpot import TPOTClassifier
+    TPOT_AVAILABLE = True
+except ImportError:
+    TPOT_AVAILABLE = False
+
+try:
+    import h2o
+    from h2o.automl import H2OAutoML
+    H2O_AVAILABLE = True
+except ImportError:
+    H2O_AVAILABLE = False
+
+
+@dataclass
+class ClassifierConfig:
+    """Конфигурация классификатора."""
+    name: str
+    model_type: str  # lr, svm, rf, xgb, lgb, catboost, ensemble, autosklearn, tpot, h2o
+    params: Dict[str, Any] = None
+    use_class_weight: bool = True
+    multilabel: bool = False  # Использовать MultiOutputClassifier для multilabel
+
+
+class ClassicalClassifiers:
+    """Класс для работы с классическими методами классификации."""
+    
+    def __init__(self, config: ClassifierConfig):
+        self.config = config
+        self.model = self._create_model()
+        self.train_time = 0.0
+        self.predict_time = 0.0
+    
+    def _create_model(self):
+        """Создает модель на основе конфигурации."""
+        model_type = self.config.model_type.lower()
+        params = self.config.params or {}
+        
+        base_model = None
+        
+        if model_type == "lr":
+            base_model = LogisticRegression(
+                max_iter=1000,
+                random_state=42,
+                class_weight="balanced" if self.config.use_class_weight else None,
+                **params
+            )
+        
+        elif model_type == "svm":
+            base_model = SVC(
+                probability=True,
+                random_state=42,
+                class_weight="balanced" if self.config.use_class_weight else None,
+                **params
+            )
+        
+        elif model_type == "rf":
+            base_model = RandomForestClassifier(
+                n_estimators=100,
+                random_state=42,
+                class_weight="balanced" if self.config.use_class_weight else None,
+                **params
+            )
+        
+        # Обертываем в MultiOutputClassifier для multilabel
+        if self.config.multilabel and base_model is not None:
+            return MultiOutputClassifier(base_model)
+        
+        if base_model is not None:
+            return base_model
+        
+        if model_type == "xgb" and XGBOOST_AVAILABLE:
+            model = xgb.XGBClassifier(
+                random_state=42,
+                eval_metric='mlogloss',
+                **params
+            )
+            return MultiOutputClassifier(model) if self.config.multilabel else model
+        
+        if model_type == "lgb" and LIGHTGBM_AVAILABLE:
+            model = lgb.LGBMClassifier(
+                random_state=42,
+                verbose=-1,
+                **params
+            )
+            return MultiOutputClassifier(model) if self.config.multilabel else model
+        
+        if model_type == "catboost" and CATBOOST_AVAILABLE:
+            model = cb.CatBoostClassifier(
+                random_state=42,
+                verbose=False,
+                **params
+            )
+            return MultiOutputClassifier(model) if self.config.multilabel else model
+        
+        if model_type == "ensemble":
+            # Voting Classifier
+            estimators = [
+                ('lr', LogisticRegression(max_iter=1000, random_state=42)),
+                ('svm', SVC(probability=True, random_state=42)),
+                ('rf', RandomForestClassifier(n_estimators=50, random_state=42))
+            ]
+            model = VotingClassifier(estimators=estimators, voting='soft')
+            return MultiOutputClassifier(model) if self.config.multilabel else model
+        
+        if model_type == "bagging":
+            base = DecisionTreeClassifier(random_state=42)
+            model = BaggingClassifier(
+                base_estimator=base,
+                n_estimators=10,
+                random_state=42,
+                **params
+            )
+            return MultiOutputClassifier(model) if self.config.multilabel else model
+        
+        if model_type == "autosklearn" and AUTOSKLEARN_AVAILABLE:
+            model = autosklearn.classification.AutoSklearnClassifier(
+                time_left_for_this_task=300,  # 5 минут
+                memory_limit=4096,
+                **params
+            )
+            # AutoSklearn может не поддерживать multilabel напрямую
+            return model
+        
+        if model_type == "tpot" and TPOT_AVAILABLE:
+            model = TPOTClassifier(
+                generations=5,
+                population_size=20,
+                verbosity=2,
+                random_state=42,
+                **params
+            )
+            # TPOT может не поддерживать multilabel напрямую
+            return model
+        
+        raise ValueError(f"Неизвестный тип модели: {model_type} или библиотека недоступна")
+    
+    def fit(self, X, y):
+        """Обучение модели."""
+        start = time.time()
+        self.model.fit(X, y)
+        self.train_time = time.time() - start
+        return self
+    
+    def predict(self, X):
+        """Предсказание классов."""
+        start = time.time()
+        predictions = self.model.predict(X)
+        self.predict_time = time.time() - start
+        return predictions
+    
+    def predict_proba(self, X):
+        """Предсказание вероятностей."""
+        if hasattr(self.model, 'predict_proba'):
+            return self.model.predict_proba(X)
+        return None
+    
+    def get_feature_importance(self):
+        """Получение важности признаков (если доступно)."""
+        if hasattr(self.model, 'feature_importances_'):
+            return self.model.feature_importances_
+        elif hasattr(self.model, 'coef_'):
+            return np.abs(self.model.coef_[0]) if len(self.model.coef_.shape) > 1 else np.abs(self.model.coef_)
+        return None
+
+
+def evaluate_classifier(y_true, y_pred, y_proba=None, 
+                        task_type: str = "multiclass") -> Dict[str, Any]:
+    """
+    Оценка качества классификатора.
+    
+    Args:
+        y_true: Истинные метки
+        y_pred: Предсказанные метки
+        y_proba: Вероятности классов (опционально)
+        task_type: Тип задачи (binary, multiclass, multilabel)
+    
+    Returns:
+        Словарь с метриками
+    """
+    metrics = {
+        "accuracy": accuracy_score(y_true, y_pred),
+        "precision_macro": precision_score(y_true, y_pred, average='macro', zero_division=0),
+        "recall_macro": recall_score(y_true, y_pred, average='macro', zero_division=0),
+        "f1_macro": f1_score(y_true, y_pred, average='macro', zero_division=0),
+        "precision_micro": precision_score(y_true, y_pred, average='micro', zero_division=0),
+        "recall_micro": recall_score(y_true, y_pred, average='micro', zero_division=0),
+        "f1_micro": f1_score(y_true, y_pred, average='micro', zero_division=0),
+    }
+    
+    # ROC-AUC для бинарной классификации
+    if task_type == "binary" and y_proba is not None and y_proba.shape[1] == 2:
+        try:
+            metrics["roc_auc"] = roc_auc_score(y_true, y_proba[:, 1])
+        except:
+            metrics["roc_auc"] = np.nan
+    
+    # ROC-AUC для многоклассовой (macro)
+    elif task_type == "multiclass" and y_proba is not None:
+        try:
+            metrics["roc_auc_macro"] = roc_auc_score(y_true, y_proba, average='macro', multi_class='ovr')
+        except:
+            metrics["roc_auc_macro"] = np.nan
+    
+    # Метрики для многометочной классификации
+    elif task_type == "multilabel":
+        # Для multilabel используем специальные метрики
+        from sklearn.metrics import hamming_loss, jaccard_score
+        try:
+            metrics["hamming_loss"] = hamming_loss(y_true, y_pred)
+            metrics["jaccard_score"] = jaccard_score(y_true, y_pred, average='macro', zero_division=0)
+            # ROC-AUC для multilabel (каждый класс отдельно, затем усреднение)
+            if y_proba is not None:
+                try:
+                    metrics["roc_auc_macro"] = roc_auc_score(y_true, y_proba, average='macro')
+                except:
+                    metrics["roc_auc_macro"] = np.nan
+        except Exception as e:
+            print(f"Ошибка при вычислении метрик multilabel: {e}")
+    
+    return metrics
+
+
+def cross_validate_classifier(model, X, y, cv=5, scoring='f1_macro'):
+    """Кросс-валидация классификатора."""
+    cv_scores = cross_val_score(model, X, y, cv=StratifiedKFold(n_splits=cv, shuffle=True, random_state=42), 
+                                scoring=scoring)
+    return {
+        "mean": cv_scores.mean(),
+        "std": cv_scores.std(),
+        "scores": cv_scores.tolist()
+    }
+
+
+def compare_classifiers(X_train, y_train, X_test, y_test,
+                       configs: List[ClassifierConfig],
+                       task_type: str = "multiclass",
+                       cv: Optional[int] = None) -> pd.DataFrame:
+    """
+    Сравнение нескольких классификаторов.
+    
+    Args:
+        X_train: Обучающие признаки
+        y_train: Обучающие метки
+        X_test: Тестовые признаки
+        y_test: Тестовые метки
+        configs: Список конфигураций классификаторов
+        task_type: Тип задачи (binary, multiclass, multilabel)
+        cv: Количество фолдов для кросс-валидации (опционально)
+    
+    Returns:
+        DataFrame с результатами сравнения
+    """
+    # Определяем, является ли задача multilabel
+    is_multilabel = task_type == "multilabel"
+    if is_multilabel:
+        # Обновляем конфигурации для multilabel
+        for cfg in configs:
+            cfg.multilabel = True
+    
+    results = []
+    
+    for cfg in configs:
+        try:
+            classifier = ClassicalClassifiers(cfg)
+            
+            # Обучение
+            classifier.fit(X_train, y_train)
+            
+            # Предсказания
+            y_pred = classifier.predict(X_test)
+            y_proba = classifier.predict_proba(X_test)
+            
+            # Для multilabel y_pred может быть 2D, нужно преобразовать
+            if is_multilabel and len(y_pred.shape) == 2:
+                # y_pred уже в правильном формате для multilabel
+                pass
+            elif is_multilabel:
+                # Если модель вернула 1D, преобразуем
+                y_pred = y_pred.reshape(-1, 1) if len(y_pred.shape) == 1 else y_pred
+            
+            # Метрики
+            metrics = evaluate_classifier(y_test, y_pred, y_proba, task_type)
+            
+            # Кросс-валидация (если запрошена)
+            cv_results = None
+            if cv:
+                cv_results = cross_validate_classifier(classifier.model, X_train, y_train, cv=cv)
+            
+            result = {
+                "Модель": cfg.name,
+                "Тип": cfg.model_type,
+                "Точность": round(metrics["accuracy"], 4),
+                "Precision (macro)": round(metrics["precision_macro"], 4),
+                "Recall (macro)": round(metrics["recall_macro"], 4),
+                "F1 (macro)": round(metrics["f1_macro"], 4),
+                "F1 (micro)": round(metrics["f1_micro"], 4),
+                "Время обучения (с)": round(classifier.train_time, 2),
+                "Время предсказания (с)": round(classifier.predict_time, 4),
+            }
+            
+            if "roc_auc" in metrics:
+                result["ROC-AUC"] = round(metrics["roc_auc"], 4)
+            elif "roc_auc_macro" in metrics:
+                result["ROC-AUC (macro)"] = round(metrics["roc_auc_macro"], 4)
+            
+            # Дополнительные метрики для multilabel
+            if task_type == "multilabel":
+                if "hamming_loss" in metrics:
+                    result["Hamming Loss"] = round(metrics["hamming_loss"], 4)
+                if "jaccard_score" in metrics:
+                    result["Jaccard Score"] = round(metrics["jaccard_score"], 4)
+            
+            if cv_results:
+                result["CV F1 (mean)"] = round(cv_results["mean"], 4)
+                result["CV F1 (std)"] = round(cv_results["std"], 4)
+            
+            results.append(result)
+            
+        except Exception as e:
+            print(f"Ошибка при обучении {cfg.name}: {e}")
+            results.append({
+                "Модель": cfg.name,
+                "Тип": cfg.model_type,
+                "Ошибка": str(e)
+            })
+    
+    return pd.DataFrame(results)
+
+
+if __name__ == "__main__":
+    # Тестирование
+    from sklearn.datasets import make_classification
+    from sklearn.model_selection import train_test_split
+    
+    X, y = make_classification(n_samples=1000, n_features=20, n_classes=3, random_state=42)
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+    
+    configs = [
+        ClassifierConfig(name="Logistic Regression", model_type="lr"),
+        ClassifierConfig(name="SVM", model_type="svm", params={"kernel": "linear"}),
+        ClassifierConfig(name="Random Forest", model_type="rf"),
+    ]
+    
+    if XGBOOST_AVAILABLE:
+        configs.append(ClassifierConfig(name="XGBoost", model_type="xgb"))
+    
+    results_df = compare_classifiers(X_train, y_train, X_test, y_test, configs)
+    print(results_df)
+

src/clustering.py

@@ -0,0 +1,378 @@
+"""
+Модуль для кластеризации текстовых данных.
+Реализует все основные классические методы кластеризации:
+- Центроидные: k-Means, Mini-Batch k-Means, Spherical k-Means
+- Плотностные: DBSCAN, HDBSCAN
+- Иерархические: агломеративная кластеризация
+- Вероятностные: Gaussian Mixture Models, LDA
+- Графовые: спектральная кластеризация
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import List, Dict, Any, Optional, Tuple
+import numpy as np
+import pandas as pd
+from sklearn.cluster import (
+    KMeans, MiniBatchKMeans, DBSCAN, AgglomerativeClustering,
+    SpectralClustering
+)
+from sklearn.mixture import GaussianMixture
+from sklearn.metrics import (
+    silhouette_score, calinski_harabasz_score, davies_bouldin_score,
+    adjusted_rand_score, normalized_mutual_info_score, v_measure_score
+)
+
+try:
+    import hdbscan
+    HDBSCAN_AVAILABLE = True
+except ImportError:
+    HDBSCAN_AVAILABLE = False
+    print("⚠️ hdbscan не установлен. HDBSCAN недоступен. Установите: pip install hdbscan")
+
+try:
+    from gensim.models import LdaModel
+    from gensim.corpora import Dictionary
+    GENSIM_AVAILABLE = True
+except ImportError:
+    GENSIM_AVAILABLE = False
+    print("⚠️ gensim не установлен. LDA недоступен.")
+
+
+@dataclass
+class ClusteringConfig:
+    """Конфигурация алгоритма кластеризации."""
+    method: str  # kmeans, minibatch_kmeans, spherical_kmeans, dbscan, hdbscan, 
+                 # agglomerative, gmm, lda, spectral
+    n_clusters: Optional[int] = None  # Для методов, требующих число кластеров
+    random_state: int = 42
+    # Специфичные параметры
+    eps: float = 0.5  # Для DBSCAN
+    min_samples: int = 5  # Для DBSCAN/HDBSCAN
+    linkage: str = "ward"  # Для Agglomerative
+    metric: str = "euclidean"  # Для Agglomerative
+    n_components: int = 10  # Для LDA
+    n_neighbors: int = 10  # Для Spectral
+
+
+class ClusteringAlgorithms:
+    """Класс для работы с алгоритмами кластеризации."""
+    
+    def __init__(self, config: ClusteringConfig):
+        self.config = config
+        self.model = self._create_model()
+        self.labels_ = None
+        self.fit_time = 0.0
+        self.predict_time = 0.0
+    
+    def _create_model(self):
+        """Создает модель кластеризации."""
+        method = self.config.method.lower()
+        
+        if method == "kmeans":
+            if self.config.n_clusters is None:
+                raise ValueError("Для k-Means требуется n_clusters")
+            return KMeans(
+                n_clusters=self.config.n_clusters,
+                random_state=self.config.random_state,
+                n_init=10
+            )
+        
+        elif method == "minibatch_kmeans":
+            if self.config.n_clusters is None:
+                raise ValueError("Для Mini-Batch k-Means требуется n_clusters")
+            return MiniBatchKMeans(
+                n_clusters=self.config.n_clusters,
+                random_state=self.config.random_state,
+                n_init=3,
+                batch_size=256
+            )
+        
+        elif method == "spherical_kmeans":
+            # Spherical k-Means через k-Means с нормализацией
+            if self.config.n_clusters is None:
+                raise ValueError("Для Spherical k-Means требуется n_clusters")
+            return KMeans(
+                n_clusters=self.config.n_clusters,
+                random_state=self.config.random_state,
+                n_init=10
+            )
+        
+        elif method == "dbscan":
+            return DBSCAN(
+                eps=self.config.eps,
+                min_samples=self.config.min_samples,
+                metric='cosine'  # Для текстов обычно используется cosine
+            )
+        
+        elif method == "hdbscan":
+            if not HDBSCAN_AVAILABLE:
+                raise ImportError("hdbscan не установлен. Установите: pip install hdbscan")
+            return hdbscan.HDBSCAN(
+                min_cluster_size=self.config.min_samples,
+                metric='euclidean',
+                cluster_selection_method='eom'
+            )
+        
+        elif method == "agglomerative":
+            if self.config.n_clusters is None:
+                raise ValueError("Для Agglomerative требуется n_clusters")
+            return AgglomerativeClustering(
+                n_clusters=self.config.n_clusters,
+                linkage=self.config.linkage,
+                metric=self.config.metric
+            )
+        
+        elif method == "gmm":
+            if self.config.n_clusters is None:
+                raise ValueError("Для GMM требуется n_clusters")
+            return GaussianMixture(
+                n_components=self.config.n_clusters,
+                random_state=self.config.random_state,
+                max_iter=100
+            )
+        
+        elif method == "spectral":
+            if self.config.n_clusters is None:
+                raise ValueError("Для Spectral требуется n_clusters")
+            return SpectralClustering(
+                n_clusters=self.config.n_clusters,
+                random_state=self.config.random_state,
+                affinity='nearest_neighbors',
+                n_neighbors=self.config.n_neighbors
+            )
+        
+        elif method == "lda":
+            # LDA обрабатывается отдельно, так как это тематическая модель
+            return None
+        
+        else:
+            raise ValueError(f"Неизвестный метод кластеризации: {method}")
+    
+    def fit(self, X: np.ndarray):
+        """Обучение модели кластеризации."""
+        start = time.time()
+        
+        # Spherical k-Means требует нормализации
+        if self.config.method.lower() == "spherical_kmeans":
+            from sklearn.preprocessing import normalize
+            X = normalize(X, norm='l2')
+        
+        # Для DBSCAN/HDBSCAN с cosine метрикой также нормализуем
+        if self.config.method.lower() in ["dbscan", "hdbscan"] and self.config.metric == "cosine":
+            from sklearn.preprocessing import normalize
+            X = normalize(X, norm='l2')
+        
+        if self.config.method.lower() == "lda":
+            # LDA обрабатывается отдельно
+            raise NotImplementedError("LDA используйте метод fit_lda")
+        
+        self.model.fit(X)
+        
+        if hasattr(self.model, 'labels_'):
+            self.labels_ = self.model.labels_
+        elif hasattr(self.model, 'predict'):
+            self.labels_ = self.model.predict(X)
+        else:
+            raise ValueError("Модель не вернула метки кластеров")
+        
+        self.fit_time = time.time() - start
+        return self
+    
+    def fit_lda(self, texts: List[str], dictionary: Optional[Any] = None):
+        """
+        Обучение LDA модели для кластеризации по темам.
+        
+        Args:
+            texts: Список текстов (уже токенизированных)
+            dictionary: Gensim Dictionary (опционально)
+        """
+        if not GENSIM_AVAILABLE:
+            raise ImportError("gensim не установлен. Установите: pip install gensim")
+        
+        if self.config.n_clusters is None:
+            raise ValueError("Для LDA требуется n_clusters (число тем)")
+        
+        from gensim.utils import simple_preprocess
+        
+        # Токенизация, если нужно
+        tokenized_texts = []
+        for text in texts:
+            if isinstance(text, str):
+                tokens = simple_preprocess(text, deacc=False, min_len=1)
+            else:
+                tokens = text
+            tokenized_texts.append(tokens)
+        
+        # Создаем словарь
+        if dictionary is None:
+            dictionary = Dictionary(tokenized_texts)
+            dictionary.filter_extremes(no_below=2, no_above=0.5)
+        
+        # Создаем корпус
+        corpus = [dictionary.doc2bow(text) for text in tokenized_texts]
+        
+        # Обучаем LDA
+        start = time.time()
+        lda_model = LdaModel(
+            corpus=corpus,
+            num_topics=self.config.n_clusters,
+            id2word=dictionary,
+            random_state=self.config.random_state,
+            passes=10,
+            alpha='auto',
+            per_word_topics=True
+        )
+        self.fit_time = time.time() - start
+        
+        # Получаем метки кластеров (темы) для каждого документа
+        self.labels_ = []
+        for doc in corpus:
+            topic_dist = lda_model.get_document_topics(doc, minimum_probability=0.0)
+            # Берем тему с максимальной вероятностью
+            best_topic = max(topic_dist, key=lambda x: x[1])[0]
+            self.labels_.append(best_topic)
+        
+        self.labels_ = np.array(self.labels_)
+        self.model = lda_model
+        self.dictionary = dictionary
+        
+        return self
+    
+    def predict(self, X: np.ndarray):
+        """Предсказание кластеров для новых данных."""
+        start = time.time()
+        
+        if self.config.method.lower() == "lda":
+            raise NotImplementedError("LDA predict требует отдел��ной реализации")
+        
+        if hasattr(self.model, 'predict'):
+            predictions = self.model.predict(X)
+        else:
+            # Для DBSCAN и некоторых других методов
+            predictions = self.model.fit_predict(X)
+        
+        self.predict_time = time.time() - start
+        return predictions
+
+
+def evaluate_clustering(X: np.ndarray, labels: np.ndarray,
+                       y_true: Optional[np.ndarray] = None) -> Dict[str, float]:
+    """
+    Оценка качества кластеризации.
+    
+    Args:
+        X: Признаки
+        labels: Предсказанные метки кластеров
+        y_true: Истинные метки (опционально, для внешних метрик)
+    
+    Returns:
+        Словарь с метриками
+    """
+    metrics = {}
+    
+    # Внутренние метрики
+    # Удаляем шумовые точки (-1) для метрик
+    valid_mask = labels != -1
+    if valid_mask.sum() > 1:
+        X_valid = X[valid_mask]
+        labels_valid = labels[valid_mask]
+        
+        if len(np.unique(labels_valid)) > 1:
+            metrics["silhouette"] = silhouette_score(X_valid, labels_valid)
+            metrics["calinski_harabasz"] = calinski_harabasz_score(X_valid, labels_valid)
+            metrics["davies_bouldin"] = davies_bouldin_score(X_valid, labels_valid)
+        else:
+            metrics["silhouette"] = -1.0
+            metrics["calinski_harabasz"] = 0.0
+            metrics["davies_bouldin"] = np.inf
+    
+    # Внешние метрики (если есть истинные метки)
+    if y_true is not None:
+        metrics["adjusted_rand_index"] = adjusted_rand_score(y_true, labels)
+        metrics["normalized_mutual_info"] = normalized_mutual_info_score(y_true, labels)
+        metrics["v_measure"] = v_measure_score(y_true, labels)
+    
+    # Статистика кластеров
+    unique_labels, counts = np.unique(labels, return_counts=True)
+    metrics["n_clusters"] = len(unique_labels[unique_labels != -1])  # Исключаем шум
+    metrics["n_noise"] = (labels == -1).sum() if -1 in labels else 0
+    metrics["avg_cluster_size"] = counts[unique_labels != -1].mean() if len(counts[unique_labels != -1]) > 0 else 0
+    
+    return metrics
+
+
+def compare_clustering_methods(X: np.ndarray,
+                              configs: List[ClusteringConfig],
+                              y_true: Optional[np.ndarray] = None) -> pd.DataFrame:
+    """
+    Сравнение нескольких методов кластеризации.
+    
+    Args:
+        X: Признаки
+        configs: Список конфигураций
+        y_true: Истинные метки (опционально)
+    
+    Returns:
+        DataFrame с результатами сравнения
+    """
+    results = []
+    
+    for cfg in configs:
+        try:
+            clusterer = ClusteringAlgorithms(cfg)
+            
+            if cfg.method.lower() == "lda":
+                # LDA требует тексты, пропускаем в этой функции
+                continue
+            
+            clusterer.fit(X)
+            metrics = evaluate_clustering(X, clusterer.labels_, y_true)
+            
+            result = {
+                "Метод": cfg.method,
+                "Число кластеров": metrics.get("n_clusters", cfg.n_clusters),
+                "Шумовые точки": metrics.get("n_noise", 0),
+                "Silhouette": round(metrics.get("silhouette", -1), 4),
+                "Calinski-Harabasz": round(metrics.get("calinski_harabasz", 0), 4),
+                "Davies-Bouldin": round(metrics.get("davies_bouldin", np.inf), 4),
+                "Время обучения (с)": round(clusterer.fit_time, 2),
+            }
+            
+            if y_true is not None:
+                result["ARI"] = round(metrics.get("adjusted_rand_index", 0), 4)
+                result["NMI"] = round(metrics.get("normalized_mutual_info", 0), 4)
+                result["V-measure"] = round(metrics.get("v_measure", 0), 4)
+            
+            results.append(result)
+            
+        except Exception as e:
+            print(f"Ошибка при кластеризации методом {cfg.method}: {e}")
+            results.append({
+                "Метод": cfg.method,
+                "Ошибка": str(e)
+            })
+    
+    return pd.DataFrame(results)
+
+
+if __name__ == "__main__":
+    # Тестирование
+    from sklearn.datasets import make_blobs
+    
+    X, y = make_blobs(n_samples=300, centers=4, random_state=42)
+    
+    configs = [
+        ClusteringConfig(method="kmeans", n_clusters=4),
+        ClusteringConfig(method="dbscan", eps=0.5, min_samples=5),
+        ClusteringConfig(method="agglomerative", n_clusters=4, linkage="ward"),
+    ]
+    
+    if HDBSCAN_AVAILABLE:
+        configs.append(ClusteringConfig(method="hdbscan", min_samples=5))
+    
+    results_df = compare_clustering_methods(X, configs, y_true=y)
+    print(results_df)
+

src/embeddings_train.py

@@ -17,10 +17,21 @@ from gensim.models import Word2Vec, FastText, Doc2Vec
 from gensim.models.doc2vec import TaggedDocument
 from gensim.utils import simple_preprocess
 
+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
+        print("⚠️ GloVe не установлен. Установите: pip install glove-python-binary")
+
 
 @dataclass
 class TrainConfig:
-    model_type: str  # w2v | fasttext | doc2vec
+    model_type: str  # w2v | fasttext | doc2vec | glove
     vector_size: int = 300
     window: int = 8
     min_count: int = 2
@@ -31,6 +42,9 @@ class TrainConfig:
     negative: int = 5
     hs: int = 0
     seed: int = 42
+    # GloVe специфичные параметры
+    alpha: float = 0.75  # для GloVe
+    x_max: int = 100  # для GloVe
 
 
 def _tokenize_corpus(texts: Iterable[str]) -> List[List[str]]:
@@ -104,6 +118,25 @@ def train_doc2vec(texts: Iterable[str], cfg: TrainConfig) -> Doc2Vec:
     return model
 
 
+def train_glove(texts: Iterable[str], cfg: TrainConfig):
+    """Обучает GloVe модель."""
+    if not GLOVE_AVAILABLE:
+        raise ImportError("GloVe не установлен. Установите: pip install glove-python-binary")
+    
+    sentences = _tokenize_corpus(texts)
+    
+    # Создаем корпус для GloVe
+    corpus = Corpus()
+    corpus.fit(sentences, window=cfg.window)
+    
+    # Обучаем модель
+    model = Glove(no_components=cfg.vector_size, learning_rate=0.05)
+    model.fit(corpus.matrix, epochs=cfg.epochs, no_threads=cfg.workers, verbose=True)
+    model.add_dictionary(corpus.dictionary)
+    
+    return model
+
+
 def train_model(texts: Iterable[str], cfg: TrainConfig):
     t0 = time.time()
     if cfg.model_type == "w2v":
@@ -112,15 +145,22 @@ def train_model(texts: Iterable[str], cfg: TrainConfig):
         model = train_fasttext(texts, cfg)
     elif cfg.model_type == "doc2vec":
         model = train_doc2vec(texts, cfg)
+    elif cfg.model_type == "glove":
+        model = train_glove(texts, cfg)
     else:
-        raise ValueError("model_type должен быть 'w2v', 'fasttext' или 'doc2vec'")
+        raise ValueError("model_type должен быть 'w2v', 'fasttext', 'doc2vec' или 'glove'")
     train_time = time.time() - t0
     return model, train_time
 
 
 def save_model(model, out_path: str) -> None:
     Path(os.path.dirname(out_path)).mkdir(parents=True, exist_ok=True)
-    model.save(out_path)
+    # GloVe имеет другой метод сохранения
+    if GLOVE_AVAILABLE and hasattr(model, 'word_vectors') and hasattr(model, 'dictionary'):
+        model.save(out_path)
+    else:
+        # Gensim модели
+        model.save(out_path)
 
 
 def load_model(path: str):
@@ -134,36 +174,107 @@ def load_model(path: str):
         return _FT.load(path)
     except Exception:
         pass
-    return _D2V.load(path)
+    try:
+        return _D2V.load(path)
+    except Exception:
+        pass
+    # Пробуем загрузить GloVe
+    if GLOVE_AVAILABLE:
+        try:
+            from glove import Glove
+            return Glove.load(path)
+        except Exception:
+            pass
+    raise ValueError(f"Не удалось загрузить модель из {path}")
 
 
 def evaluate_neighbors(model, test_words: List[str], topn: int = 10) -> Dict[str, List[Tuple[str, float]]]:
     results: Dict[str, List[Tuple[str, float]]] = {}
-    kv = model.wv if hasattr(model, "wv") else model
-    for w in test_words:
-        if w in kv:
-            results[w] = kv.most_similar(w, topn=topn)
-        else:
-            results[w] = []
+    # GloVe имеет другой API
+    if GLOVE_AVAILABLE and hasattr(model, 'word_vectors') and hasattr(model, 'dictionary'):
+        # GloVe модель - вычисляем ближайших соседей вручную
+        for w in test_words:
+            try:
+                if w in model.dictionary:
+                    vec_w = model.word_vectors[model.dictionary[w]]
+                    similarities = []
+                    for word, idx in model.dictionary.items():
+                        if word != w:
+                            vec = model.word_vectors[idx]
+                            sim = float(np.dot(vec_w, vec) / (np.linalg.norm(vec_w) * np.linalg.norm(vec)))
+                            similarities.append((word, sim))
+                    similarities.sort(key=lambda x: x[1], reverse=True)
+                    results[w] = similarities[:topn]
+                else:
+                    results[w] = []
+            except:
+                results[w] = []
+    else:
+        # Gensim модели (Word2Vec, FastText, Doc2Vec)
+        kv = model.wv if hasattr(model, "wv") else model
+        for w in test_words:
+            if w in kv:
+                results[w] = kv.most_similar(w, topn=topn)
+            else:
+                results[w] = []
     return results
 
 
 def cosine_similarity(model, word_pairs: List[Tuple[str, str]]) -> List[Tuple[str, str, float]]:
     out: List[Tuple[str, str, float]] = []
-    kv = model.wv if hasattr(model, "wv") else model
-    for a, b in word_pairs:
-        if a in kv and b in kv:
-            out.append((a, b, float(kv.similarity(a, b))))
-        else:
-            out.append((a, b, np.nan))
+    # GloVe имеет другой API
+    if GLOVE_AVAILABLE and hasattr(model, 'word_vectors') and hasattr(model, 'dictionary'):
+        # GloVe модель
+        for a, b in word_pairs:
+            try:
+                if a in model.dictionary and b in model.dictionary:
+                    vec_a = model.word_vectors[model.dictionary[a]]
+                    vec_b = model.word_vectors[model.dictionary[b]]
+                    sim = float(np.dot(vec_a, vec_b) / (np.linalg.norm(vec_a) * np.linalg.norm(vec_b)))
+                    out.append((a, b, sim))
+                else:
+                    out.append((a, b, np.nan))
+            except:
+                out.append((a, b, np.nan))
+    else:
+        # Gensim модели
+        kv = model.wv if hasattr(model, "wv") else model
+        for a, b in word_pairs:
+            if a in kv and b in kv:
+                out.append((a, b, float(kv.similarity(a, b))))
+            else:
+                out.append((a, b, np.nan))
     return out
 
 
 def word_analogy(model, a: str, b: str, c: str, topn: int = 10) -> List[Tuple[str, float]]:
-    kv = model.wv if hasattr(model, "wv") else model
-    if all(token in kv for token in [a, b, c]):
-        return kv.most_similar(positive=[b, c], negative=[a], topn=topn)
-    return []
+    # GloVe не имеет встроенного метода для аналогий, вычисляем вручную
+    if GLOVE_AVAILABLE and hasattr(model, 'word_vectors') and hasattr(model, 'dictionary'):
+        # GloVe модель - вычисляем аналогию вручную
+        try:
+            if all(token in model.dictionary for token in [a, b, c]):
+                vec_a = model.word_vectors[model.dictionary[a]]
+                vec_b = model.word_vectors[model.dictionary[b]]
+                vec_c = model.word_vectors[model.dictionary[c]]
+                target = vec_b - vec_a + vec_c
+                # Находим ближайшие векторы
+                similarities = []
+                for word, idx in model.dictionary.items():
+                    if word not in [a, b, c]:
+                        vec = model.word_vectors[idx]
+                        sim = float(np.dot(target, vec) / (np.linalg.norm(target) * np.linalg.norm(vec)))
+                        similarities.append((word, sim))
+                similarities.sort(key=lambda x: x[1], reverse=True)
+                return similarities[:topn]
+        except:
+            pass
+        return []
+    else:
+        # Gensim модели
+        kv = model.wv if hasattr(model, "wv") else model
+        if all(token in kv for token in [a, b, c]):
+            return kv.most_similar(positive=[b, c], negative=[a], topn=topn)
+        return []
 
 
 def export_training_report(cfg: TrainConfig, train_time: float, model_path: str, extra: Optional[Dict[str, Any]] = None) -> pd.DataFrame:

src/imbalance_handling.py

@@ -0,0 +1,385 @@
+"""
+Методы борьбы с дисбалансом классов в текстовых данных:
+взвешивание классов, сэмплирование, аугментация текстов.
+"""
+
+from __future__ import annotations
+
+from typing import List, Tuple, Dict, Any, Optional
+from collections import Counter
+
+import numpy as np
+from sklearn.utils import resample
+from sklearn.utils.class_weight import compute_class_weight
+
+try:
+    from imblearn.over_sampling import SMOTE, ADASYN, RandomOverSampler
+    from imblearn.under_sampling import RandomUnderSampler
+    IMBLEARN_AVAILABLE = True
+except ImportError:
+    IMBLEARN_AVAILABLE = False
+    print("⚠️ imbalanced-learn не установлен. SMOTE/ADASYN недоступны.")
+
+try:
+    import nlpaug.augmenter.word as naw
+    NLPAUG_AVAILABLE = True
+except ImportError:
+    NLPAUG_AVAILABLE = False
+    print("⚠️ nlpaug не установлен. Аугментация текстов недоступна.")
+
+
+def compute_class_weights(y: np.ndarray, method: str = "balanced") -> Dict[int, float]:
+    """
+    Вычисляет веса классов.
+    
+    Args:
+        y: Массив меток
+        method: Метод вычисления весов ('balanced', 'balanced_subsample', или dict)
+    
+    Returns:
+        Словарь {класс: вес}
+    """
+    classes = np.unique(y)
+    weights = compute_class_weight(method, classes=classes, y=y)
+    return dict(zip(classes, weights))
+
+
+def random_oversample(X: np.ndarray, y: np.ndarray, 
+                     strategy: Optional[Dict[int, int]] = None) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Случайная перевыборка миноритарных классов.
+    
+    Args:
+        X: Признаки
+        y: Метки
+        strategy: Словарь {класс: целевое количество} или None для балансировки
+    
+    Returns:
+        Перевыбранные X, y
+    """
+    if strategy is None:
+        # Балансируем до максимального класса
+        class_counts = Counter(y)
+        max_count = max(class_counts.values())
+        strategy = {cls: max_count for cls in class_counts.keys()}
+    
+    X_resampled = []
+    y_resampled = []
+    
+    for cls in strategy.keys():
+        mask = y == cls
+        X_cls = X[mask]
+        y_cls = y[mask]
+        
+        if len(X_cls) < strategy[cls]:
+            # Перевыборка
+            X_cls_resampled, y_cls_resampled = resample(
+                X_cls, y_cls,
+                n_samples=strategy[cls],
+                random_state=42
+            )
+        else:
+            X_cls_resampled, y_cls_resampled = X_cls, y_cls
+        
+        X_resampled.append(X_cls_resampled)
+        y_resampled.append(y_cls_resampled)
+    
+    X_resampled = np.vstack(X_resampled)
+    y_resampled = np.hstack(y_resampled)
+    
+    # Перемешивание
+    indices = np.random.permutation(len(X_resampled))
+    return X_resampled[indices], y_resampled[indices]
+
+
+def random_undersample(X: np.ndarray, y: np.ndarray,
+                      strategy: Optional[Dict[int, int]] = None) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Случайная недо-выборка мажоритарных классов.
+    
+    Args:
+        X: Признаки
+        y: Метки
+        strategy: Словарь {класс: целевое количество} или None для балансировки
+    
+    Returns:
+        Недо-выбранные X, y
+    """
+    if strategy is None:
+        # Балансируем до минимального класса
+        class_counts = Counter(y)
+        min_count = min(class_counts.values())
+        strategy = {cls: min_count for cls in class_counts.keys()}
+    
+    X_resampled = []
+    y_resampled = []
+    
+    for cls in strategy.keys():
+        mask = y == cls
+        X_cls = X[mask]
+        y_cls = y[mask]
+        
+        if len(X_cls) > strategy[cls]:
+            # Недо-выборка
+            X_cls_resampled, y_cls_resampled = resample(
+                X_cls, y_cls,
+                n_samples=strategy[cls],
+                random_state=42
+            )
+        else:
+            X_cls_resampled, y_cls_resampled = X_cls, y_cls
+        
+        X_resampled.append(X_cls_resampled)
+        y_resampled.append(y_cls_resampled)
+    
+    X_resampled = np.vstack(X_resampled)
+    y_resampled = np.hstack(y_resampled)
+    
+    # Перемешивание
+    indices = np.random.permutation(len(X_resampled))
+    return X_resampled[indices], y_resampled[indices]
+
+
+def smote_oversample(X: np.ndarray, y: np.ndarray,
+                    k_neighbors: int = 5) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    SMOTE (Synthetic Minority Oversampling Technique) для векторизованных текстов.
+    
+    Args:
+        X: Векториз��ванные признаки
+        y: Метки
+        k_neighbors: Количество соседей для SMOTE
+    
+    Returns:
+        Перевыбранные X, y
+    """
+    if not IMBLEARN_AVAILABLE:
+        raise ImportError("imbalanced-learn не установлен. Установите: pip install imbalanced-learn")
+    
+    smote = SMOTE(k_neighbors=k_neighbors, random_state=42)
+    X_resampled, y_resampled = smote.fit_resample(X, y)
+    return X_resampled, y_resampled
+
+
+def adasyn_oversample(X: np.ndarray, y: np.ndarray,
+                     n_neighbors: int = 5) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    ADASYN (Adaptive Synthetic Sampling) для векторизованных текстов.
+    
+    Args:
+        X: Векторизованные признаки
+        y: Метки
+        n_neighbors: Количество соседей для ADASYN
+    
+    Returns:
+        Перевыбранные X, y
+    """
+    if not IMBLEARN_AVAILABLE:
+        raise ImportError("imbalanced-learn не установлен. Установите: pip install imbalanced-learn")
+    
+    adasyn = ADASYN(n_neighbors=n_neighbors, random_state=42)
+    X_resampled, y_resampled = adasyn.fit_resample(X, y)
+    return X_resampled, y_resampled
+
+
+def synonym_replacement(text: str, num_replacements: int = 1) -> str:
+    """
+    Замена слов синонимами (упрощенная версия).
+    
+    Примечание: Для полноценной работы требуется словарь синонимов или WordNet.
+    """
+    # Упрощенная версия - просто возвращаем исходный текст
+    # Для реальной работы нужен словарь синонимов или библиотека типа pymorphy2 + словари
+    return text
+
+
+def random_deletion(text: str, p: float = 0.1) -> str:
+    """
+    Случайное удаление слов из текста.
+    
+    Args:
+        text: Исходный текст
+        p: Вероятность удаления каждого слова
+    
+    Returns:
+        Текст с удаленными словами
+    """
+    words = text.split()
+    if len(words) == 0:
+        return text
+    
+    # Удаляем слова с вероятностью p
+    kept_words = [w for w in words if np.random.random() > p]
+    
+    if len(kept_words) == 0:
+        # Если все слова удалены, возвращаем одно случайное слово
+        return np.random.choice(words)
+    
+    return ' '.join(kept_words)
+
+
+def random_insertion(text: str, num_insertions: int = 1) -> str:
+    """
+    Случайная вставка слов в текст (упрощенная версия).
+    
+    Args:
+        text: Исходный текст
+        num_insertions: Количество вставок
+    
+    Returns:
+        Текст с вставленными словами
+    """
+    words = text.split()
+    if len(words) == 0:
+        return text
+    
+    for _ in range(num_insertions):
+        # Вставляем случайное слово в случайную позицию
+        random_word = np.random.choice(words)
+        random_pos = np.random.randint(0, len(words) + 1)
+        words.insert(random_pos, random_word)
+    
+    return ' '.join(words)
+
+
+def random_swap(text: str, num_swaps: int = 1) -> str:
+    """
+    Случайная перестановка слов в тексте.
+    
+    Args:
+        text: Исходный текст
+        num_swaps: Количество перестановок
+    
+    Returns:
+        Текст с переставленными словами
+    """
+    words = text.split()
+    if len(words) < 2:
+        return text
+    
+    for _ in range(num_swaps):
+        idx1, idx2 = np.random.choice(len(words), size=2, replace=False)
+        words[idx1], words[idx2] = words[idx2], words[idx1]
+    
+    return ' '.join(words)
+
+
+def easy_data_augmentation(text: str, 
+                           alpha_sr: float = 0.1,
+                           alpha_ri: float = 0.1,
+                           alpha_rs: float = 0.1,
+                           num_aug: int = 1) -> List[str]:
+    """
+    Easy Data Augmentation (EDA) для текста.
+    
+    Args:
+        text: Исходный текст
+        alpha_sr: Параметр для synonym replacement
+        alpha_ri: Параметр для random insertion
+        alpha_rs: Параметр для random swap
+        num_aug: Количество аугментированных вариантов
+    
+    Returns:
+        Список аугментированных текстов
+    """
+    num_words = len(text.split())
+    augmented_texts = []
+    
+    for _ in range(num_aug):
+        augmented = text
+        
+        # Synonym replacement
+        if np.random.random() < alpha_sr:
+            augmented = synonym_replacement(augmented)
+        
+        # Random insertion
+        if np.random.random() < alpha_ri:
+            n_insert = max(1, int(alpha_ri * num_words))
+            augmented = random_insertion(augmented, n_insert)
+        
+        # Random swap
+        if np.random.random() < alpha_rs:
+            n_swap = max(1, int(alpha_rs * num_words))
+            augmented = random_swap(augmented, n_swap)
+        
+        # Random deletion
+        if np.random.random() < alpha_sr:
+            augmented = random_deletion(augmented, alpha_sr)
+        
+        augmented_texts.append(augmented)
+    
+    return augmented_texts
+
+
+def augment_texts(texts: List[str], labels: List[int],
+                  target_class: Optional[int] = None,
+                  num_aug: int = 1,
+                  method: str = "eda") -> Tuple[List[str], List[int]]:
+    """
+    Аугментация текстов для балансировки классов.
+    
+    Args:
+        texts: Список текстов
+        labels: Список меток
+        target_class: Класс для аугментации (None = все миноритарные)
+        num_aug: Количество аугментированных вариантов на текст
+        method: Метод аугментации ('eda', 'nlpaug')
+    
+    Returns:
+        Расширенные списки текстов и меток
+    """
+    augmented_texts = list(texts)
+    augmented_labels = list(labels)
+    
+    if target_class is None:
+        # Определяем миноритарные классы
+        class_counts = Counter(labels)
+        min_count = min(class_counts.values())
+        target_classes = [cls for cls, count in class_counts.items() if count == min_count]
+    else:
+        target_classes = [target_class]
+    
+    for cls in target_classes:
+        cls_texts = [text for text, label in zip(texts, labels) if label == cls]
+        
+        for text in cls_texts:
+            if method == "eda":
+                aug_texts = easy_data_augmentation(text, num_aug=num_aug)
+            elif method == "nlpaug" and NLPAUG_AVAILABLE:
+                # Использование nlpaug (требует настройки)
+                aug_texts = [text]  # Заглушка
+            else:
+                aug_texts = [text]
+            
+            augmented_texts.extend(aug_texts)
+            augmented_labels.extend([cls] * len(aug_texts))
+    
+    return augmented_texts, augmented_labels
+
+
+if __name__ == "__main__":
+    # Тестирование
+    import numpy as np
+    
+    # Создаем несбалансированные данные
+    X = np.random.randn(100, 50)
+    y = np.array([0] * 80 + [1] * 20)
+    
+    print(f"Исходное распределение: {Counter(y)}")
+    
+    # Перевыборка
+    X_resampled, y_resampled = random_oversample(X, y)
+    print(f"После перевыборки: {Counter(y_resampled)}")
+    
+    # SMOTE (если доступен)
+    if IMBLEARN_AVAILABLE:
+        X_smote, y_smote = smote_oversample(X, y)
+        print(f"После SMOTE: {Counter(y_smote)}")
+    
+    # Аугментация текстов
+    texts = ["Это тестовый текст", "Другой пример текста"] * 50
+    labels = [0] * 80 + [1] * 20
+    
+    aug_texts, aug_labels = augment_texts(texts, labels, num_aug=2)
+    print(f"После аугментации: {len(aug_texts)} текстов, распределение: {Counter(aug_labels)}")
+

src/model_evaluation.py

@@ -0,0 +1,359 @@
+"""
+Модуль для оценки качества моделей классификации и настройки гиперпараметров.
+Включает кросс-валидацию, подбор гиперпараметров и комплексные метрики.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import List, Dict, Any, Optional, Tuple, Union
+from dataclasses import dataclass
+
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import (
+    GridSearchCV, RandomizedSearchCV, StratifiedKFold, 
+    cross_val_score, train_test_split
+)
+from sklearn.metrics import (
+    accuracy_score, precision_score, recall_score, f1_score,
+    roc_auc_score, classification_report, confusion_matrix,
+    precision_recall_curve, roc_curve, average_precision_score
+)
+
+try:
+    import optuna
+    OPTUNA_AVAILABLE = True
+except ImportError:
+    OPTUNA_AVAILABLE = False
+    print("⚠️ Optuna не установлен. Bayesian optimization недоступен.")
+
+try:
+    from hyperopt import fmin, tpe, hp, Trials, STATUS_OK
+    HYPEROPT_AVAILABLE = True
+except ImportError:
+    HYPEROPT_AVAILABLE = False
+    print("⚠️ Hyperopt не установлен. Bayesian optimization недоступен.")
+
+
+@dataclass
+class EvaluationMetrics:
+    """Контейнер для метрик оценки."""
+    accuracy: float
+    precision_macro: float
+    recall_macro: float
+    f1_macro: float
+    precision_micro: float
+    recall_micro: float
+    f1_micro: float
+    roc_auc: Optional[float] = None
+    pr_auc: Optional[float] = None
+    train_time: float = 0.0
+    predict_time: float = 0.0
+
+
+def evaluate_classifier(y_true: np.ndarray, 
+                       y_pred: np.ndarray,
+                       y_proba: Optional[np.ndarray] = None,
+                       task_type: str = "multiclass") -> EvaluationMetrics:
+    """
+    Комплексная оценка классификатора.
+    
+    Args:
+        y_true: Истинные метки
+        y_pred: Предсказанные метки
+        y_proba: Вероятности классов
+        task_type: Тип задачи (binary, multiclass, multilabel)
+    
+    Returns:
+        Объект EvaluationMetrics
+    """
+    metrics = EvaluationMetrics(
+        accuracy=accuracy_score(y_true, y_pred),
+        precision_macro=precision_score(y_true, y_pred, average='macro', zero_division=0),
+        recall_macro=recall_score(y_true, y_pred, average='macro', zero_division=0),
+        f1_macro=f1_score(y_true, y_pred, average='macro', zero_division=0),
+        precision_micro=precision_score(y_true, y_pred, average='micro', zero_division=0),
+        recall_micro=recall_score(y_true, y_pred, average='micro', zero_division=0),
+        f1_micro=f1_score(y_true, y_pred, average='micro', zero_division=0),
+    )
+    
+    # ROC-AUC для бинарной классификации
+    if task_type == "binary" and y_proba is not None:
+        if y_proba.shape[1] == 2:
+            try:
+                metrics.roc_auc = roc_auc_score(y_true, y_proba[:, 1])
+                metrics.pr_auc = average_precision_score(y_true, y_proba[:, 1])
+            except:
+                pass
+        elif y_proba.shape[1] == 1:
+            try:
+                metrics.roc_auc = roc_auc_score(y_true, y_proba.flatten())
+                metrics.pr_auc = average_precision_score(y_true, y_proba.flatten())
+            except:
+                pass
+    
+    # ROC-AUC для многоклассовой (macro)
+    elif task_type == "multiclass" and y_proba is not None:
+        try:
+            metrics.roc_auc = roc_auc_score(y_true, y_proba, average='macro', multi_class='ovr')
+        except:
+            pass
+    
+    return metrics
+
+
+def cross_validate(model, X: np.ndarray, y: np.ndarray,
+                   cv: int = 5,
+                   scoring: str = 'f1_macro',
+                   return_train_score: bool = False) -> Dict[str, Any]:
+    """
+    Кросс-валидация модели.
+    
+    Args:
+        model: Модель с интерфейсом sklearn
+        X: Признаки
+        y: Метки
+        cv: Количество фолдов
+        scoring: Метрика для оценки
+        return_train_score: Возвращать ли оценки на обучении
+    
+    Returns:
+        Словарь с результатами кросс-валидации
+    """
+    cv_scores = cross_val_score(
+        model, X, y,
+        cv=StratifiedKFold(n_splits=cv, shuffle=True, random_state=42),
+        scoring=scoring,
+        return_train_score=return_train_score
+    )
+    
+    result = {
+        "mean": float(cv_scores.mean()),
+        "std": float(cv_scores.std()),
+        "scores": cv_scores.tolist()
+    }
+    
+    if return_train_score and hasattr(cv_scores, 'train_scores'):
+        result["train_mean"] = float(cv_scores.train_scores.mean())
+        result["train_std"] = float(cv_scores.train_scores.std())
+    
+    return result
+
+
+def grid_search(model, X: np.ndarray, y: np.ndarray,
+                param_grid: Dict[str, List[Any]],
+                cv: int = 5,
+                scoring: str = 'f1_macro',
+                n_jobs: int = -1) -> Dict[str, Any]:
+    """
+    Подбор гиперпараметров методом Grid Search.
+    
+    Args:
+        model: Модель с интерфейсом sklearn
+        X: Признаки
+        y: Метки
+        param_grid: Сетка параметров
+        cv: Количество фолдов
+        scoring: Метрика для оценки
+        n_jobs: Количество параллельных задач
+    
+    Returns:
+        Словарь с лучшими параметрами и результатами
+    """
+    grid_search = GridSearchCV(
+        model,
+        param_grid,
+        cv=StratifiedKFold(n_splits=cv, shuffle=True, random_state=42),
+        scoring=scoring,
+        n_jobs=n_jobs,
+        verbose=1
+    )
+    
+    start = time.time()
+    grid_search.fit(X, y)
+    search_time = time.time() - start
+    
+    return {
+        "best_params": grid_search.best_params_,
+        "best_score": float(grid_search.best_score_),
+        "best_model": grid_search.best_estimator_,
+        "search_time": search_time,
+        "cv_results": grid_search.cv_results_
+    }
+
+
+def random_search(model, X: np.ndarray, y: np.ndarray,
+                 param_distributions: Dict[str, List[Any]],
+                 n_iter: int = 50,
+                 cv: int = 5,
+                 scoring: str = 'f1_macro',
+                 n_jobs: int = -1) -> Dict[str, Any]:
+    """
+    Подбор гиперпараметров методом Random Search.
+    
+    Args:
+        model: Модель с интерфейсом sklearn
+        X: Признаки
+        y: Метки
+        param_distributions: Распределения параметров
+        n_iter: Количество итераций
+        cv: Количество фолдов
+        scoring: Метрика для оценки
+        n_jobs: Количество параллельных задач
+    
+    Returns:
+        Словарь с лучшими параметрами и результатами
+    """
+    random_search = RandomizedSearchCV(
+        model,
+        param_distributions,
+        n_iter=n_iter,
+        cv=StratifiedKFold(n_splits=cv, shuffle=True, random_state=42),
+        scoring=scoring,
+        n_jobs=n_jobs,
+        random_state=42,
+        verbose=1
+    )
+    
+    start = time.time()
+    random_search.fit(X, y)
+    search_time = time.time() - start
+    
+    return {
+        "best_params": random_search.best_params_,
+        "best_score": float(random_search.best_score_),
+        "best_model": random_search.best_estimator_,
+        "search_time": search_time,
+        "cv_results": random_search.cv_results_
+    }
+
+
+def optuna_optimize(model_class, X: np.ndarray, y: np.ndarray,
+                    param_space: Dict[str, Any],
+                    n_trials: int = 50,
+                    cv: int = 5,
+                    scoring: str = 'f1_macro') -> Dict[str, Any]:
+    """
+    Подбор гиперпараметров методом Bayesian Optimization (Optuna).
+    
+    Args:
+        model_class: Класс модели
+        X: Признаки
+        y: Метки
+        param_space: Пространство параметров (функции для Optuna)
+        n_trials: Количество испытаний
+        cv: Количество фолдов
+        scoring: Метрика для оценки
+    
+    Returns:
+        Словарь с лучшими параметрами и результатами
+    """
+    if not OPTUNA_AVAILABLE:
+        raise ImportError("Optuna не установлен. Установите: pip install optuna")
+    
+    def objective(trial):
+        params = {}
+        for param_name, param_func in param_space.items():
+            params[param_name] = param_func(trial)
+        
+        model = model_class(**params)
+        scores = cross_val_score(
+            model, X, y,
+            cv=StratifiedKFold(n_splits=cv, shuffle=True, random_state=42),
+            scoring=scoring
+        )
+        return scores.mean()
+    
+    study = optuna.create_study(direction='maximize', study_name='classifier_optimization')
+    start = time.time()
+    study.optimize(objective, n_trials=n_trials, show_progress_bar=True)
+    search_time = time.time() - start
+    
+    # Обучаем лучшую модель
+    best_model = model_class(**study.best_params)
+    best_model.fit(X, y)
+    
+    return {
+        "best_params": study.best_params,
+        "best_score": float(study.best_value),
+        "best_model": best_model,
+        "search_time": search_time,
+        "study": study
+    }
+
+
+def create_confusion_matrix_plot(y_true: np.ndarray, y_pred: np.ndarray,
+                                class_names: Optional[List[str]] = None) -> pd.DataFrame:
+    """
+    Создает матрицу ошибок.
+    
+    Args:
+        y_true: Истинные метки
+        y_pred: Предсказанные метки
+        class_names: Названия классов
+    
+    Returns:
+        DataFrame с матрицей ошибок
+    """
+    cm = confusion_matrix(y_true, y_pred)
+    
+    if class_names is None:
+        class_names = [f"Класс {i}" for i in range(len(cm))]
+    
+    df = pd.DataFrame(cm, index=class_names, columns=class_names)
+    return df
+
+
+def create_classification_report_df(y_true: np.ndarray, y_pred: np.ndarray,
+                                   class_names: Optional[List[str]] = None) -> pd.DataFrame:
+    """
+    Создает отчет о классификации.
+    
+    Args:
+        y_true: Истинные метки
+        y_pred: Предсказанные метки
+        class_names: Названия классов
+    
+    Returns:
+        DataFrame с отчетом
+    """
+    report = classification_report(y_true, y_pred, target_names=class_names, output_dict=True)
+    df = pd.DataFrame(report).transpose()
+    return df
+
+
+if __name__ == "__main__":
+    # Тестирование
+    from sklearn.datasets import make_classification
+    from sklearn.linear_model import LogisticRegression
+    
+    X, y = make_classification(n_samples=1000, n_features=20, n_classes=3, random_state=42)
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+    
+    # Обучение модели
+    model = LogisticRegression(max_iter=1000, random_state=42)
+    model.fit(X_train, y_train)
+    
+    # Оценка
+    y_pred = model.predict(X_test)
+    y_proba = model.predict_proba(X_test)
+    
+    metrics = evaluate_classifier(y_test, y_pred, y_proba, task_type="multiclass")
+    print("Метрики:")
+    print(f"Accuracy: {metrics.accuracy:.4f}")
+    print(f"F1 (macro): {metrics.f1_macro:.4f}")
+    print(f"ROC-AUC: {metrics.roc_auc:.4f if metrics.roc_auc else 'N/A'}")
+    
+    # Кросс-валидация
+    cv_results = cross_validate(model, X_train, y_train, cv=5)
+    print(f"\nКросс-валидация F1: {cv_results['mean']:.4f} ± {cv_results['std']:.4f}")
+    
+    # Grid Search
+    param_grid = {
+        'C': [0.1, 1, 10],
+        'penalty': ['l1', 'l2']
+    }
+    # grid_results = grid_search(model, X_train, y_train, param_grid, cv=3)
+    # print(f"\nЛучшие параметры (Grid Search): {grid_results['best_params']}")
+

src/model_interpretation.py

@@ -0,0 +1,367 @@
+"""
+Модуль для интерпретации моделей классификации: SHAP, LIME, важность признаков,
+визуализация внимания для нейросетей и трансформеров.
+"""
+
+from __future__ import annotations
+
+from typing import List, Dict, Any, Optional, Tuple
+import numpy as np
+import pandas as pd
+
+try:
+    import shap
+    SHAP_AVAILABLE = True
+except ImportError:
+    SHAP_AVAILABLE = False
+    print("⚠️ SHAP не установлен. Установите: pip install shap")
+
+try:
+    from lime import lime_text
+    from lime.lime_text import LimeTextExplainer
+    LIME_AVAILABLE = True
+except ImportError:
+    LIME_AVAILABLE = False
+    print("⚠️ LIME не установлен. Установите: pip install lime")
+
+try:
+    import matplotlib.pyplot as plt
+    import seaborn as sns
+    MATPLOTLIB_AVAILABLE = True
+except ImportError:
+    MATPLOTLIB_AVAILABLE = False
+    print("⚠️ Matplotlib не установлен. Визуализация недоступна.")
+
+
+def get_feature_importance_linear(model, feature_names: Optional[List[str]] = None) -> pd.DataFrame:
+    """
+    Извлекает важность признаков для линейных моделей (LR, SVM).
+    
+    Args:
+        model: Обученная модель
+        feature_names: Названия признаков
+    
+    Returns:
+        DataFrame с важностью признаков
+    """
+    if hasattr(model, 'coef_'):
+        coef = model.coef_
+        if len(coef.shape) > 1:
+            # Многоклассовая классификация - берем среднее по классам
+            importance = np.abs(coef).mean(axis=0)
+        else:
+            importance = np.abs(coef)
+        
+        if feature_names is None:
+            feature_names = [f"Признак {i}" for i in range(len(importance))]
+        
+        df = pd.DataFrame({
+            "Признак": feature_names,
+            "Важность": importance
+        }).sort_values("Важность", ascending=False)
+        
+        return df
+    
+    return pd.DataFrame()
+
+
+def get_feature_importance_tree(model, feature_names: Optional[List[str]] = None) -> pd.DataFrame:
+    """
+    Извлекает важность признаков для tree-based моделей (RF, XGBoost, etc.).
+    
+    Args:
+        model: Обученная модель
+        feature_names: Названия признаков
+    
+    Returns:
+        DataFrame с важностью признаков
+    """
+    if hasattr(model, 'feature_importances_'):
+        importance = model.feature_importances_
+        
+        if feature_names is None:
+            feature_names = [f"Признак {i}" for i in range(len(importance))]
+        
+        df = pd.DataFrame({
+            "Признак": feature_names,
+            "Важность": importance
+        }).sort_values("Важность", ascending=False)
+        
+        return df
+    
+    return pd.DataFrame()
+
+
+def get_tfidf_important_words(vectorizer, model, class_idx: int = 0, top_k: int = 20) -> pd.DataFrame:
+    """
+    Извлекает наиболее важные слова для TF-IDF векторизации.
+    
+    Args:
+        vectorizer: Обученный векторизатор
+        model: Обученная модель
+        class_idx: Индекс класса
+        top_k: Количество топ-слов
+    
+    Returns:
+        DataFrame с важными словами
+    """
+    if not hasattr(model, 'coef_'):
+        return pd.DataFrame()
+    
+    coef = model.coef_[class_idx] if len(model.coef_.shape) > 1 else model.coef_
+    
+    if hasattr(vectorizer, 'get_feature_names_out'):
+        feature_names = vectorizer.get_feature_names_out()
+    elif hasattr(vectorizer, 'get_feature_names'):
+        feature_names = vectorizer.get_feature_names()
+    else:
+        return pd.DataFrame()
+    
+    # Сортируем по важности
+    indices = np.argsort(np.abs(coef))[-top_k:][::-1]
+    
+    df = pd.DataFrame({
+        "Слово": [feature_names[i] for i in indices],
+        "Коэффициент": [coef[i] for i in indices],
+        "Абсолютное значение": [np.abs(coef[i]) for i in indices]
+    })
+    
+    return df
+
+
+def explain_with_shap(model, X: np.ndarray, 
+                     feature_names: Optional[List[str]] = None,
+                     max_samples: int = 100) -> Optional[shap.Explanation]:
+    """
+    Объяснение предсказаний модели с помощью SHAP.
+    
+    Args:
+        model: Обученная модель с методом predict_proba
+        X: Признаки для объяснения
+        feature_names: Названия признаков
+        max_samples: Максимальное количество образцов для объя��нения
+    
+    Returns:
+        SHAP Explanation объект или None
+    """
+    if not SHAP_AVAILABLE:
+        print("SHAP не установлен. Установите: pip install shap")
+        return None
+    
+    # Ограничиваем количество образцов для производительности
+    if len(X) > max_samples:
+        indices = np.random.choice(len(X), max_samples, replace=False)
+        X_sample = X[indices]
+    else:
+        X_sample = X
+    
+    try:
+        # Создаем explainer в зависимости от типа модели
+        if hasattr(model, 'predict_proba'):
+            explainer = shap.Explainer(model, X_sample)
+        else:
+            # Для моделей без predict_proba используем KernelExplainer
+            explainer = shap.KernelExplainer(model.predict, X_sample)
+        
+        shap_values = explainer(X_sample)
+        
+        if feature_names is not None:
+            shap_values.feature_names = feature_names
+        
+        return shap_values
+    
+    except Exception as e:
+        print(f"Ошибка при создании SHAP объяснения: {e}")
+        return None
+
+
+def explain_with_lime_text(model, texts: List[str],
+                          vectorizer: Any,
+                          class_names: Optional[List[str]] = None,
+                          num_features: int = 10) -> List[Dict[str, Any]]:
+    """
+    Объяснение предсказаний модели с помощью LIME для текста.
+    
+    Args:
+        model: Обученная модель
+        texts: Тексты для объяснения
+        vectorizer: Векторизатор текстов
+        class_names: Названия классов
+        num_features: Количество важных признаков для показа
+    
+    Returns:
+        Список объяснений для каждого текста
+    """
+    if not LIME_AVAILABLE:
+        print("LIME не установлен. Установите: pip install lime")
+        return []
+    
+    explainer = LimeTextExplainer(class_names=class_names)
+    
+    def predict_proba_wrapper(texts_list):
+        """Обертка для predict_proba с векторизацией."""
+        X = vectorizer.transform(texts_list)
+        if hasattr(model, 'predict_proba'):
+            return model.predict_proba(X)
+        else:
+            # Для моделей без predict_proba
+            predictions = model.predict(X)
+            # Создаем псевдо-вероятности
+            proba = np.zeros((len(predictions), len(np.unique(predictions))))
+            for i, pred in enumerate(predictions):
+                proba[i, pred] = 1.0
+            return proba
+    
+    explanations = []
+    for text in texts:
+        try:
+            explanation = explainer.explain_instance(
+                text,
+                predict_proba_wrapper,
+                num_features=num_features
+            )
+            
+            # Извлекаем важные слова
+            exp_list = explanation.as_list()
+            explanations.append({
+                "text": text,
+                "important_words": exp_list,
+                "prediction": explanation.predict_proba.argmax() if hasattr(explanation, 'predict_proba') else None
+            })
+        except Exception as e:
+            print(f"Ошибка при объяснении текста: {e}")
+            explanations.append({
+                "text": text,
+                "important_words": [],
+                "prediction": None
+            })
+    
+    return explanations
+
+
+def visualize_attention_weights(attention_weights: np.ndarray,
+                               tokens: List[str],
+                               save_path: Optional[str] = None) -> None:
+    """
+    Визуализация весов внимания для трансформерных моделей.
+    
+    Args:
+        attention_weights: Матрица весов внимания (n_heads, seq_len, seq_len) или (seq_len, seq_len)
+        tokens: Список токенов
+        save_path: Путь для сохранения изображения
+    """
+    if not MATPLOTLIB_AVAILABLE:
+        print("Matplotlib не установлен. Визуализация недоступна.")
+        return
+    
+    # Если несколько голов внимания, усредняем
+    if len(attention_weights.shape) == 3:
+        attention_weights = attention_weights.mean(axis=0)
+    
+    # Ограничиваем длину для визуализации
+    max_len = min(50, len(tokens))
+    attention_weights = attention_weights[:max_len, :max_len]
+    tokens = tokens[:max_len]
+    
+    plt.figure(figsize=(12, 10))
+    sns.heatmap(
+        attention_weights,
+        xticklabels=tokens,
+        yticklabels=tokens,
+        cmap='Blues',
+        cbar=True
+    )
+    plt.title("Визуализация весов внимания")
+    plt.xlabel("Токены")
+    plt.ylabel("Токены")
+    plt.xticks(rotation=45, ha='right')
+    plt.yticks(rotation=0)
+    plt.tight_layout()
+    
+    if save_path:
+        plt.savefig(save_path, dpi=300, bbox_inches='tight')
+    
+    plt.show()
+
+
+def analyze_error_cases(y_true: np.ndarray, y_pred: np.ndarray,
+                       texts: Optional[List[str]] = None,
+                       top_k: int = 10) -> pd.DataFrame:
+    """
+    Анализ случаев, где модель ошибается.
+    
+    Args:
+        y_true: Истинные метки
+        y_pred: Предсказанные метки
+        texts: Тексты (опционально)
+        top_k: Количество примеров для показа
+    
+    Returns:
+        DataFrame с примерами ошибок
+    """
+    errors = y_true != y_pred
+    error_indices = np.where(errors)[0]
+    
+    if len(error_indices) == 0:
+        return pd.DataFrame({"Сообщение": ["Ошибок не найдено"]})
+    
+    # Ограничиваем количество
+    if len(error_indices) > top_k:
+        error_indices = np.random.choice(error_indices, top_k, replace=False)
+    
+    results = []
+    for idx in error_indices:
+        result = {
+            "Индекс": int(idx),
+            "Истинный класс": int(y_true[idx]),
+            "Предсказанный класс": int(y_pred[idx])
+        }
+        if texts is not None:
+            result["Текст"] = texts[idx][:200] + "..." if len(texts[idx]) > 200 else texts[idx]
+        results.append(result)
+    
+    return pd.DataFrame(results)
+
+
+if __name__ == "__main__":
+    # Тестирование
+    from sklearn.datasets import make_classification
+    from sklearn.linear_model import LogisticRegression
+    from sklearn.feature_extraction.text import TfidfVectorizer
+    
+    # Создаем тестовые данные
+    texts = [
+        "Это положительный отзыв о продукте",
+        "Отрицательный отзыв не понравилось",
+        "Нейтральный отзыв нормально",
+    ] * 10
+    
+    vectorizer = TfidfVectorizer()
+    X = vectorizer.fit_transform(texts).toarray()
+    y = np.array([0, 1, 2] * 10)
+    
+    # Обучение модели
+    model = LogisticRegression(max_iter=1000, random_state=42)
+    model.fit(X, y)
+    
+    # Важность признаков
+    feature_importance = get_feature_importance_linear(model)
+    print("Важность признаков (топ-10):")
+    print(feature_importance.head(10))
+    
+    # Важные слова для TF-IDF
+    important_words = get_tfidf_important_words(vectorizer, model, class_idx=0, top_k=10)
+    print("\nВажные слова для класса 0:")
+    print(important_words)
+    
+    # SHAP (если доступен)
+    if SHAP_AVAILABLE:
+        shap_values = explain_with_shap(model, X[:5], max_samples=5)
+        if shap_values is not None:
+            print("\nSHAP объяснение создано успешно")
+    
+    # LIME (если доступен)
+    if LIME_AVAILABLE:
+        lime_explanations = explain_with_lime_text(model, texts[:3], vectorizer)
+        print(f"\nLIME объяснения: {len(lime_explanations)} создано")
+

src/neural_classifiers.py

@@ -0,0 +1,306 @@
+"""
+Нейросетевые методы классификации текстов: MLP, CNN, LSTM, GRU, гибридные архитектуры.
+Примечание: Для трансформеров (BERT, RuBERT) требуется установка transformers и torch.
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import List, Dict, Any, Optional, Tuple
+
+import numpy as np
+import pandas as pd
+
+try:
+    import tensorflow as tf
+    from tensorflow import keras
+    from tensorflow.keras import layers, models, callbacks
+    TENSORFLOW_AVAILABLE = True
+except ImportError:
+    TENSORFLOW_AVAILABLE = False
+    print("⚠️ TensorFlow не установлен. Нейросетевые модели недоступны.")
+
+try:
+    import torch
+    import torch.nn as nn
+    from transformers import AutoTokenizer, AutoModel
+    TRANSFORMERS_AVAILABLE = True
+except ImportError:
+    TRANSFORMERS_AVAILABLE = False
+    print("⚠️ PyTorch/Transformers не установлены. Трансформерные модели недоступны.")
+
+
+@dataclass
+class NeuralConfig:
+    """Конфигурация нейросетевой модели."""
+    model_type: str  # mlp, cnn, lstm, gru, cnn_lstm, birnn_attention
+    input_dim: int
+    num_classes: int
+    embedding_dim: int = 300
+    hidden_dim: int = 128
+    dropout: float = 0.5
+    learning_rate: float = 0.001
+    epochs: int = 10
+    batch_size: int = 32
+    validation_split: float = 0.2
+
+
+class NeuralClassifiers:
+    """Класс для работы с нейросетевыми классификаторами."""
+    
+    def __init__(self, config: NeuralConfig):
+        if not TENSORFLOW_AVAILABLE:
+            raise ImportError("TensorFlow не установлен. Установите: pip install tensorflow")
+        
+        self.config = config
+        self.model = self._create_model()
+        self.history = None
+        self.train_time = 0.0
+        self.predict_time = 0.0
+    
+    def _create_model(self):
+        """Создает нейросетевую модель."""
+        model_type = self.config.model_type.lower()
+        
+        if model_type == "mlp":
+            return self._create_mlp()
+        elif model_type == "cnn":
+            return self._create_cnn()
+        elif model_type == "lstm":
+            return self._create_lstm()
+        elif model_type == "gru":
+            return self._create_gru()
+        elif model_type == "cnn_lstm":
+            return self._create_cnn_lstm()
+        elif model_type == "birnn_attention":
+            return self._create_birnn_attention()
+        else:
+            raise ValueError(f"Неизвестный тип модели: {model_type}")
+    
+    def _create_mlp(self):
+        """Многослойный персептрон."""
+        model = models.Sequential([
+            layers.Dense(self.config.hidden_dim, activation='relu', input_dim=self.config.input_dim),
+            layers.Dropout(self.config.dropout),
+            layers.Dense(self.config.hidden_dim // 2, activation='relu'),
+            layers.Dropout(self.config.dropout),
+            layers.Dense(self.config.num_classes, activation='softmax')
+        ])
+        model.compile(
+            optimizer=keras.optimizers.Adam(learning_rate=self.config.learning_rate),
+            loss='sparse_categorical_crossentropy',
+            metrics=['accuracy']
+        )
+        return model
+    
+    def _create_cnn(self):
+        """Сверточная нейросеть для текста (Kim CNN)."""
+        # Для CNN нужна последовательность токенов, поэтому используем embedding
+        # В упрощенной версии работаем с уже векторизованными данными
+        model = models.Sequential([
+            layers.Reshape((self.config.input_dim, 1), input_shape=(self.config.input_dim,)),
+            layers.Conv1D(128, 3, activation='relu'),
+            layers.MaxPooling1D(2),
+            layers.Conv1D(64, 3, activation='relu'),
+            layers.GlobalMaxPooling1D(),
+            layers.Dense(self.config.hidden_dim, activation='relu'),
+            layers.Dropout(self.config.dropout),
+            layers.Dense(self.config.num_classes, activation='softmax')
+        ])
+        model.compile(
+            optimizer=keras.optimizers.Adam(learning_rate=self.config.learning_rate),
+            loss='sparse_categorical_crossentropy',
+            metrics=['accuracy']
+        )
+        return model
+    
+    def _create_lstm(self):
+        """LSTM сеть."""
+        model = models.Sequential([
+            layers.Reshape((self.config.input_dim, 1), input_shape=(self.config.input_dim,)),
+            layers.LSTM(self.config.hidden_dim, return_sequences=False),
+            layers.Dropout(self.config.dropout),
+            layers.Dense(self.config.num_classes, activation='softmax')
+        ])
+        model.compile(
+            optimizer=keras.optimizers.Adam(learning_rate=self.config.learning_rate),
+            loss='sparse_categorical_crossentropy',
+            metrics=['accuracy']
+        )
+        return model
+    
+    def _create_gru(self):
+        """GRU сеть."""
+        model = models.Sequential([
+            layers.Reshape((self.config.input_dim, 1), input_shape=(self.config.input_dim,)),
+            layers.GRU(self.config.hidden_dim, return_sequences=False),
+            layers.Dropout(self.config.dropout),
+            layers.Dense(self.config.num_classes, activation='softmax')
+        ])
+        model.compile(
+            optimizer=keras.optimizers.Adam(learning_rate=self.config.learning_rate),
+            loss='sparse_categorical_crossentropy',
+            metrics=['accuracy']
+        )
+        return model
+    
+    def _create_cnn_lstm(self):
+        """Гибридная CNN + LSTM архитектура."""
+        model = models.Sequential([
+            layers.Reshape((self.config.input_dim, 1), input_shape=(self.config.input_dim,)),
+            layers.Conv1D(64, 3, activation='relu'),
+            layers.MaxPooling1D(2),
+            layers.LSTM(self.config.hidden_dim, return_sequences=False),
+            layers.Dropout(self.config.dropout),
+            layers.Dense(self.config.num_classes, activation='softmax')
+        ])
+        model.compile(
+            optimizer=keras.optimizers.Adam(learning_rate=self.config.learning_rate),
+            loss='sparse_categorical_crossentropy',
+            metrics=['accuracy']
+        )
+        return model
+    
+    def _create_birnn_attention(self):
+        """Двунаправленная RNN с механизмом внимания (упрощенная версия)."""
+        # Упрощенная версия без настоящего attention механизма
+        model = models.Sequential([
+            layers.Reshape((self.config.input_dim, 1), input_shape=(self.config.input_dim,)),
+            layers.Bidirectional(layers.LSTM(self.config.hidden_dim, return_sequences=True)),
+            layers.GlobalAveragePooling1D(),  # Простая агрегация вместо attention
+            layers.Dropout(self.config.dropout),
+            layers.Dense(self.config.num_classes, activation='softmax')
+        ])
+        model.compile(
+            optimizer=keras.optimizers.Adam(learning_rate=self.config.learning_rate),
+            loss='sparse_categorical_crossentropy',
+            metrics=['accuracy']
+        )
+        return model
+    
+    def fit(self, X, y, validation_data=None):
+        """Обучение модели."""
+        if not TENSORFLOW_AVAILABLE:
+            raise ImportError("TensorFlow не установлен")
+        
+        start = time.time()
+        
+        callbacks_list = [
+            callbacks.EarlyStopping(monitor='val_loss', patience=3, restore_best_weights=True),
+            callbacks.ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=2, min_lr=1e-7)
+        ]
+        
+        if validation_data is None and self.config.validation_split > 0:
+            self.history = self.model.fit(
+                X, y,
+                epochs=self.config.epochs,
+                batch_size=self.config.batch_size,
+                validation_split=self.config.validation_split,
+                callbacks=callbacks_list,
+                verbose=1
+            )
+        else:
+            self.history = self.model.fit(
+                X, y,
+                epochs=self.config.epochs,
+                batch_size=self.config.batch_size,
+                validation_data=validation_data,
+                callbacks=callbacks_list,
+                verbose=1
+            )
+        
+        self.train_time = time.time() - start
+        return self
+    
+    def predict(self, X):
+        """Предсказание классов."""
+        start = time.time()
+        predictions = self.model.predict(X, verbose=0)
+        self.predict_time = time.time() - start
+        return np.argmax(predictions, axis=1)
+    
+    def predict_proba(self, X):
+        """Предсказание вероятностей."""
+        return self.model.predict(X, verbose=0)
+
+
+class TransformerClassifier:
+    """
+    Классификатор на основе трансформеров (BERT, RuBERT).
+    Требует установки transformers и torch.
+    """
+    
+    def __init__(self, model_name: str = "DeepPavlov/rubert-base-cased", 
+                 num_classes: int = 2,
+                 max_length: int = 512,
+                 learning_rate: float = 2e-5,
+                 epochs: int = 3,
+                 batch_size: int = 16):
+        if not TRANSFORMERS_AVAILABLE:
+            raise ImportError(
+                "PyTorch и Transformers не установлены. "
+                "Установите: pip install torch transformers"
+            )
+        
+        self.model_name = model_name
+        self.num_classes = num_classes
+        self.max_length = max_length
+        self.learning_rate = learning_rate
+        self.epochs = epochs
+        self.batch_size = batch_size
+        
+        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
+        self.model = AutoModel.from_pretrained(model_name)
+        
+        # Добавляем классификационный слой
+        self.classifier = nn.Sequential(
+            nn.Linear(self.model.config.hidden_size, 256),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+            nn.Linear(256, num_classes)
+        )
+        
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model.to(self.device)
+        self.classifier.to(self.device)
+    
+    def fit(self, texts: List[str], labels: List[int]):
+        """Обучение трансформерной модели."""
+        # Реализация обучения требует более сложной логики
+        # Здесь только заглушка
+        raise NotImplementedError(
+            "Полная реализация обучения трансформеров требует дополнительной настройки. "
+            "Рекомендуется использовать готовые решения из библиотеки transformers."
+        )
+    
+    def predict(self, texts: List[str]):
+        """Предсказание классов."""
+        raise NotImplementedError("См. fit()")
+
+
+if __name__ == "__main__":
+    # Тестирование (только если TensorFlow доступен)
+    if TENSORFLOW_AVAILABLE:
+        from sklearn.datasets import make_classification
+        from sklearn.model_selection import train_test_split
+        
+        X, y = make_classification(n_samples=1000, n_features=100, n_classes=3, random_state=42)
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+        
+        config = NeuralConfig(
+            model_type="mlp",
+            input_dim=100,
+            num_classes=3,
+            epochs=5
+        )
+        
+        classifier = NeuralClassifiers(config)
+        classifier.fit(X_train, y_train)
+        predictions = classifier.predict(X_test)
+        
+        from sklearn.metrics import accuracy_score
+        print(f"Точность: {accuracy_score(y_test, predictions):.4f}")
+    else:
+        print("TensorFlow не установлен. Тесты пропущены.")
+

src/streamlit_app.py

@@ -13,6 +13,7 @@ from typing import List, Dict, Any, Optional
 
 import streamlit as st
 import pandas as pd
+import numpy as np
 import plotly.express as px
 import plotly.graph_objects as go
 from plotly.subplots import make_subplots
@@ -41,6 +42,14 @@ 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
 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
+from src.neural_classifiers import NeuralClassifiers, NeuralConfig
+from src.imbalance_handling import compute_class_weights, random_oversample, smote_oversample, augment_texts
+from src.model_evaluation import evaluate_classifier as eval_classifier_full, cross_validate, grid_search
+from src.model_interpretation import get_feature_importance_linear, get_tfidf_important_words, explain_with_shap, explain_with_lime_text
+from src.text_to_vector import vectorize_texts
+from src.clustering import ClusteringAlgorithms, ClusteringConfig, evaluate_clustering, compare_clustering_methods
 
 
 # Настройка страницы
@@ -317,8 +326,8 @@ def main():
     st.session_state["processed_texts"] = processed_texts
     texts = processed_texts
     
-    # Главные вкладки ЛР1/ЛР2
-    main_tabs = st.tabs(["Токенизация", "Векторизация", "Эмбеддинги"])
+    # Главные вкладки ЛР1/ЛР2/ЛР3/ЛР4
+    main_tabs = st.tabs(["Токенизация", "Векторизация", "Эмбеддинги", "Классификация", "Кластеризация"])
 
     # ======== Токенизация (ЛР1) ========
     with main_tabs[0]:
@@ -501,7 +510,7 @@ def main():
                 index=0, horizontal=True,
                 help="Предобработанные = применены настройки из блока Предобработка на левой панели"
             )
-            model_type = st.selectbox("Модель", ["w2v", "fasttext", "doc2vec"], index=0)
+            model_type = st.selectbox("Модель", ["w2v", "fasttext", "doc2vec", "glove"], index=0)
             vector_size = st.slider("Размерность", 50, 600, 300, step=50)
             window = st.slider("Окно контекста", 2, 15, 8)
             min_count = st.slider("Min count", 1, 20, 2)
@@ -580,6 +589,284 @@ def main():
                 if st.button("🧩 Аналогия"):
                     st.write(eval_analogy(model, ana_a, ana_b, ana_c, topn=10))
 
+    # ======== Классификация (ЛР3) ========
+    with main_tabs[3]:
+        st.subheader("📊 Классификация текстов")
+        
+        if not texts:
+            st.warning("⚠️ Загрузите тексты для классификации.")
+        else:
+            # Выбор типа задачи
+            task_type = st.radio(
+                "Тип задачи классификации:",
+                ["Бинарная", "Многоклассовая", "Многометочная"],
+                horizontal=True
+            )
+            
+            # Создание разметки (упрощенная версия - пользователь должен разметить данные заранее)
+            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("🔧 Предобработка")
+            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))])  # Ограничиваем для демо
+            
+            # Векторизация
+            st.subheader("🧮 Векторизация")
+            vectorization_method = st.selectbox(
+                "Метод векторизации:",
+                ["tfidf", "bow"]
+            )
+            
+            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}")
+            
+            # Классификация
+            if "X_classification" in st.session_state:
+                X = st.session_state["X_classification"]
+                y = labels[:len(processed_texts)]
+                
+                # Разделение на 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
+                    )
+                else:
+                    X_train, X_test, y_train, y_test = train_test_split(
+                        X, y, test_size=0.2, random_state=42, stratify=y
+                    )
+                
+                st.subheader("🎯 Обучение классификаторов")
+                selected_models = st.multiselect(
+                    "Выберите модели:",
+                    ["Logistic Regression", "SVM", "Random Forest"],
+                    default=["Logistic Regression", "Random Forest"]
+                )
+                
+                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"))
+                    
+                    with st.spinner("Обучение моделей..."):
+                        # Определяем тип задачи
+                        if task_type == "Многометочная":
+                            task_type_str = "multilabel"
+                        elif task_type == "Многоклассовая":
+                            task_type_str = "multiclass"
+                        else:
+                            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:
+                        st.subheader("🔍 Важные слова")
+                        vectorizer = st.session_state["vectorizer_classification"]
+                        if "Logistic Regression" in selected_models:
+                            # Создаем простую модель для демонстрации
+                            from sklearn.linear_model import LogisticRegression
+                            model = LogisticRegression(max_iter=1000, random_state=42)
+                            model.fit(X_train, y_train)
+                            important_words = get_tfidf_important_words(vectorizer, model, class_idx=0, top_k=20)
+                            st.dataframe(important_words, use_container_width=True)
+
+    # ======== Кластеризация (ЛР4) ========
+    with main_tabs[4]:
+        st.subheader("🔍 Кластеризация текстов")
+        
+        if not texts:
+            st.warning("⚠️ Загрузите тексты для кластеризации.")
+        else:
+            # Предобработка
+            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(200, len(texts))])  # Ограничиваем для демо
+            
+            # Векторизация
+            st.subheader("🧮 Векторизация")
+            vectorization_method = st.selectbox(
+                "Метод векторизации:",
+                ["tfidf", "bm25"],
+                key="clustering_vectorization"
+            )
+            
+            if st.button("🔨 Векторизовать тексты", key="vectorize_for_clustering"):
+                with st.spinner("Векторизация..."):
+                    try:
+                        X, vectorizer_obj = vectorize_texts(
+                            processed_texts,
+                            method=vectorization_method,
+                            max_features=500
+                        )
+                        st.session_state["X_clustering"] = X
+                        st.session_state["vectorizer_clustering"] = vectorizer_obj
+                        st.success(f"Векторизовано {len(processed_texts)} текстов, размерность: {X.shape}")
+                    except Exception as e:
+                        st.error(f"Ошибка векторизации: {e}")
+            
+            # Кластеризация
+            if "X_clustering" in st.session_state:
+                X = st.session_state["X_clustering"]
+                
+                st.subheader("🎯 Кластеризация")
+                clustering_method = st.selectbox(
+                    "Метод кластеризации:",
+                    ["kmeans", "dbscan", "agglomerative", "gmm"],
+                    key="clustering_method"
+                )
+                
+                n_clusters = None
+                if clustering_method in ["kmeans", "agglomerative", "gmm"]:
+                    n_clusters = st.slider("Число кластеров", 2, 20, 5, key="n_clusters")
+                
+                if clustering_method == "dbscan":
+                    eps = st.slider("EPS", 0.1, 1.0, 0.5, 0.1, key="dbscan_eps")
+                    min_samples = st.slider("Min samples", 2, 10, 5, key="dbscan_min_samples")
+                else:
+                    eps = 0.5
+                    min_samples = 5
+                
+                if st.button("🚀 Выполнить кластеризацию", key="run_clustering"):
+                    with st.spinner("Кластеризация..."):
+                        try:
+                            config = ClusteringConfig(
+                                method=clustering_method,
+                                n_clusters=n_clusters,
+                                eps=eps,
+                                min_samples=min_samples
+                            )
+                            clusterer = ClusteringAlgorithms(config)
+                            clusterer.fit(X)
+                            
+                            # Оценка качества
+                            metrics = evaluate_clustering(X, clusterer.labels_)
+                            
+                            st.session_state["clustering_labels"] = clusterer.labels_
+                            st.session_state["clustering_metrics"] = metrics
+                            st.session_state["clustering_model"] = clusterer
+                            
+                            st.success("Кластеризация завершена!")
+                        except Exception as e:
+                            st.error(f"Ошибка кластеризации: {e}")
+                
+                if "clustering_labels" in st.session_state:
+                    labels = st.session_state["clustering_labels"]
+                    metrics = st.session_state["clustering_metrics"]
+                    
+                    st.subheader("📊 Результаты кластеризации")
+                    
+                    # Метрики
+                    col1, col2, col3, col4 = st.columns(4)
+                    with col1:
+                        st.metric("Число кластеров", metrics.get("n_clusters", 0))
+                    with col2:
+                        st.metric("Silhouette", round(metrics.get("silhouette", -1), 3))
+                    with col3:
+                        st.metric("Calinski-Harabasz", round(metrics.get("calinski_harabasz", 0), 2))
+                    with col4:
+                        st.metric("Davies-Bouldin", round(metrics.get("davies_bouldin", np.inf), 3))
+                    
+                    # Распределение по кластерам
+                    unique_labels, counts = np.unique(labels, return_counts=True)
+                    cluster_df = pd.DataFrame({
+                        "Кластер": unique_labels,
+                        "Количество документов": counts
+                    })
+                    st.dataframe(cluster_df, use_container_width=True)
+                    
+                    # Примеры документов из кластеров
+                    st.subheader("📝 Примеры документов по кластерам")
+                    selected_cluster = st.selectbox(
+                        "Выберите кластер:",
+                        unique_labels[unique_labels != -1] if -1 in labels else unique_labels,
+                        key="selected_cluster"
+                    )
+                    
+                    cluster_indices = np.where(labels == selected_cluster)[0]
+                    if len(cluster_indices) > 0:
+                        sample_indices = cluster_indices[:5]  # Показываем первые 5
+                        for idx in sample_indices:
+                            st.text_area(
+                                f"Документ {idx}",
+                                processed_texts[idx][:200] + "..." if len(processed_texts[idx]) > 200 else processed_texts[idx],
+                                height=100,
+                                key=f"doc_{idx}"
+                            )
+                    
+                    # Визуализация (если возможно)
+                    if X.shape[1] > 2:
+                        st.subheader("📈 Визуализация кластеров")
+                        try:
+                            from sklearn.decomposition import PCA
+                            pca = PCA(n_components=2)
+                            X_2d = pca.fit_transform(X)
+                            
+                            import plotly.express as px
+                            viz_df = pd.DataFrame({
+                                "x": X_2d[:, 0],
+                                "y": X_2d[:, 1],
+                                "Кластер": labels.astype(str)
+                            })
+                            fig = px.scatter(viz_df, x="x", y="y", color="Кластер", 
+                                            title="Проекция кластеров (PCA)")
+                            fig.update_traces(marker_size=5)
+                            st.plotly_chart(fig, use_container_width=True)
+                        except Exception as e:
+                            st.warning(f"Не удалось создать визуализацию: {e}")
+
 
 if __name__ == "__main__":
     main()

src/text_preprocessing.py

@@ -0,0 +1,368 @@
+"""
+Модуль для предобработки текстовых данных для задач классификации.
+Включает очистку, токенизацию, лемматизацию, векторизацию и извлечение мета-признаков.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import List, Dict, Any, Optional, Tuple
+from dataclasses import dataclass
+
+import numpy as np
+from bs4 import BeautifulSoup
+import spacy
+from sklearn.feature_extraction.text import TfidfVectorizer, CountVectorizer
+from gensim.models import Word2Vec, FastText, Doc2Vec
+from gensim.utils import simple_preprocess
+
+from src.text_cleaner import clean_text, remove_html, normalize_whitespace
+from src.classical_vectorizers import ClassicalVectorizers, VectorizationConfig
+
+
+@dataclass
+class PreprocessingConfig:
+    """Конфигурация предобработки текста."""
+    lowercase: bool = True
+    remove_html: bool = True
+    remove_urls: bool = True
+    remove_emails: bool = True
+    remove_numbers: bool = False
+    lemmatize: bool = True
+    remove_stopwords: bool = False
+    min_token_length: int = 2
+    emoji_to_text: bool = True
+
+
+class TextPreprocessor:
+    """Класс для предобработки текстов для классификации."""
+    
+    def __init__(self, config: Optional[PreprocessingConfig] = None):
+        self.config = config or PreprocessingConfig()
+        self.nlp = None
+        if self.config.lemmatize:
+            try:
+                self.nlp = spacy.load("ru_core_news_sm")
+            except OSError:
+                try:
+                    self.nlp = spacy.load("ru_core_news_md")
+                except OSError:
+                    print("⚠️ spaCy русская модель не найдена. Лемматизация отключена.")
+                    self.config.lemmatize = False
+    
+    def _remove_urls(self, text: str) -> str:
+        """Удаляет URL из текста."""
+        url_pattern = r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\(\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+'
+        return re.sub(url_pattern, '', text)
+    
+    def _remove_emails(self, text: str) -> str:
+        """Удаляет email адреса из текста."""
+        email_pattern = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b'
+        return re.sub(email_pattern, '', text)
+    
+    def _emoji_to_text(self, text: str) -> str:
+        """Заменяет эмодзи на текстовое описание (упрощенная версия)."""
+        # Базовые замены для русскоязычного контекста
+        emoji_map = {
+            '😀': ' улыбка ',
+            '😃': ' радость ',
+            '😄': ' смех ',
+            '😁': ' веселье ',
+            '😆': ' хохот ',
+            '😅': ' пот ',
+            '😂': ' слезы радости ',
+            '🤣': ' хохот ',
+            '😊': ' улыбка ',
+            '😇': ' ангел ',
+            '🙂': ' улыбка ',
+            '🙃': ' перевернутое лицо ',
+            '😉': ' подмигивание ',
+            '😌': ' облегчение ',
+            '😍': ' любовь ',
+            '🥰': ' любовь ',
+            '😘': ' поцелуй ',
+            '😗': ' поцелуй ',
+            '😙': ' поцелуй ',
+            '😚': ' поцелуй ',
+            '😋': ' вкусно ',
+            '😛': ' язык ',
+            '😜': ' подмигивание ',
+            '😝': ' язык ',
+            '😞': ' грусть ',
+            '😟': ' беспокойство ',
+            '😠': ' злость ',
+            '😡': ' ярость ',
+            '😢': ' плач ',
+            '😣': ' страдание ',
+            '😤': ' упрямство ',
+            '😥': ' разочарование ',
+            '😦': ' удивление ',
+            '😧': ' шок ',
+            '😨': ' страх ',
+            '😩': ' усталость ',
+            '😪': ' сонливость ',
+            '😫': ' усталость ',
+            '😬': ' напряжение ',
+            '😭': ' плач ',
+            '😮': ' удивление ',
+            '😯': ' удивление ',
+            '😰': ' тревога ',
+            '😱': ' ужас ',
+            '😲': ' шок ',
+            '😳': ' смущение ',
+            '😴': ' сон ',
+            '😵': ' головокружение ',
+            '😶': ' без слов ',
+            '😷': ' маска ',
+            '🤐': ' молчание ',
+            '🤒': ' болезнь ',
+            '🤕': ' травма ',
+            '🤢': ' тошнота ',
+            '🤣': ' хохот ',
+            '🤤': ' слюни ',
+            '🤥': ' ложь ',
+            '🤧': ' чихание ',
+            '🤨': ' подозрение ',
+            '🤩': ' звезды ',
+            '🤪': ' безумие ',
+            '🤫': ' тишина ',
+            '🤬': ' ругательство ',
+            '🤭': ' секрет ',
+            '🤮': ' рвота ',
+            '🤯': ' взрыв мозга ',
+        }
+        for emoji, replacement in emoji_map.items():
+            text = text.replace(emoji, replacement)
+        return text
+    
+    def preprocess(self, text: str) -> str:
+        """Основная функция предобработки текста."""
+        if not text:
+            return ""
+        
+        # Удаление HTML
+        if self.config.remove_html:
+            text = remove_html(text)
+        
+        # Удаление URL
+        if self.config.remove_urls:
+            text = self._remove_urls(text)
+        
+        # Удаление email
+        if self.config.remove_emails:
+            text = self._remove_emails(text)
+        
+        # Замена эмодзи
+        if self.config.emoji_to_text:
+            text = self._emoji_to_text(text)
+        
+        # Нормализация пробелов
+        text = normalize_whitespace(text)
+        
+        # Приведение к нижнему регистру
+        if self.config.lowercase:
+            text = text.lower()
+        
+        # Удаление чисел (опционально)
+        if self.config.remove_numbers:
+            text = re.sub(r'\d+', '', text)
+        
+        # Лемматизация
+        if self.config.lemmatize and self.nlp:
+            doc = self.nlp(text)
+            tokens = [token.lemma_ for token in doc if not token.is_punct and not token.is_space]
+            text = ' '.join(tokens)
+        else:
+            # Простая токенизация
+            tokens = simple_preprocess(text, deacc=False, min_len=self.config.min_token_length)
+            text = ' '.join(tokens)
+        
+        # Удаление стоп-слов (если не использовалась лемматизация со spaCy)
+        if self.config.remove_stopwords and not (self.config.lemmatize and self.nlp):
+            from src.text_cleaner import remove_stopwords_tokens
+            tokens = text.split()
+            tokens = remove_stopwords_tokens(tokens)
+            text = ' '.join(tokens)
+        
+        # Финальная нормализация
+        text = normalize_whitespace(text)
+        
+        return text
+    
+    def preprocess_batch(self, texts: List[str]) -> List[str]:
+        """Предобработка списка текстов."""
+        return [self.preprocess(text) for text in texts]
+
+
+def extract_meta_features(texts: List[str]) -> np.ndarray:
+    """
+    Извлекает мета-признаки из текстов.
+    
+    Возвращает:
+        Массив формы (n_texts, n_features) с признаками:
+        - длина текста (символы)
+        - средняя длина слова
+        - количество уникальных слов
+        - доля знаков препинания
+        - доля заглавных букв
+        - доля цифр
+    """
+    features = []
+    
+    for text in texts:
+        if not text:
+            features.append([0, 0, 0, 0, 0, 0])
+            continue
+        
+        # Длина текста
+        text_length = len(text)
+        
+        # Токены
+        tokens = text.split()
+        if not tokens:
+            features.append([text_length, 0, 0, 0, 0, 0])
+            continue
+        
+        # Средняя длина слова
+        avg_word_length = np.mean([len(token) for token in tokens])
+        
+        # Количество уникальных слов
+        unique_words = len(set(tokens))
+        
+        # Доля знаков препинания
+        punct_count = sum(1 for c in text if c in '.,;:!?()[]{}"\'-')
+        punct_ratio = punct_count / text_length if text_length > 0 else 0
+        
+        # Доля заглавных букв
+        upper_count = sum(1 for c in text if c.isupper())
+        upper_ratio = upper_count / text_length if text_length > 0 else 0
+        
+        # Доля цифр
+        digit_count = sum(1 for c in text if c.isdigit())
+        digit_ratio = digit_count / text_length if text_length > 0 else 0
+        
+        features.append([
+            text_length,
+            avg_word_length,
+            unique_words,
+            punct_ratio,
+            upper_ratio,
+            digit_ratio
+        ])
+    
+    return np.array(features)
+
+
+def vectorize_with_classical(texts: List[str], method: str = "tfidf", 
+                            ngram_range: Tuple[int, int] = (1, 2),
+                            max_features: Optional[int] = None) -> Tuple[np.ndarray, Any]:
+    """
+    Векторизация текстов классическими методами.
+    
+    Args:
+        texts: Список текстов
+        method: Метод векторизации (tfidf, bow)
+        ngram_range: Диапазон n-грамм
+        max_features: Максимальное количество признаков
+    
+    Returns:
+        Матрица признаков и векторизатор
+    """
+    config = VectorizationConfig(
+        method=method,
+        ngram_range=ngram_range,
+        max_features=max_features
+    )
+    vectorizer = ClassicalVectorizers(config)
+    X, _ = vectorizer.fit_transform(texts)
+    return X.toarray() if hasattr(X, 'toarray') else X, vectorizer
+
+
+def vectorize_with_embeddings(texts: List[str], 
+                              model: Any,
+                              aggregation: str = "mean") -> np.ndarray:
+    """
+    Векторизация текстов с использованием обученных эмбеддингов.
+    
+    Args:
+        texts: Список текстов (уже токенизированных)
+        model: Обученная модель (Word2Vec, FastText, Doc2Vec)
+        aggregation: Метод агрегации (mean, max, sum)
+    
+    Returns:
+        Матрица эмбеддингов документов
+    """
+    if isinstance(model, Doc2Vec):
+        # Doc2Vec имеет встроенный метод для документов
+        vectors = []
+        for text in texts:
+            tokens = simple_preprocess(text, deacc=False, min_len=1)
+            if tokens:
+                vec = model.infer_vector(tokens)
+            else:
+                vec = np.zeros(model.vector_size)
+            vectors.append(vec)
+        return np.array(vectors)
+    
+    # Word2Vec / FastText
+    kv = model.wv if hasattr(model, 'wv') else model
+    vector_size = kv.vector_size if hasattr(kv, 'vector_size') else model.vector_size
+    
+    vectors = []
+    for text in texts:
+        tokens = simple_preprocess(text, deacc=False, min_len=1)
+        word_vectors = []
+        for token in tokens:
+            if token in kv:
+                word_vectors.append(kv[token])
+        
+        if not word_vectors:
+            vectors.append(np.zeros(vector_size))
+            continue
+        
+        word_vectors = np.array(word_vectors)
+        
+        if aggregation == "mean":
+            doc_vector = np.mean(word_vectors, axis=0)
+        elif aggregation == "max":
+            doc_vector = np.max(word_vectors, axis=0)
+        elif aggregation == "sum":
+            doc_vector = np.sum(word_vectors, axis=0)
+        else:
+            doc_vector = np.mean(word_vectors, axis=0)
+        
+        vectors.append(doc_vector)
+    
+    return np.array(vectors)
+
+
+if __name__ == "__main__":
+    # Тестирование
+    sample_texts = [
+        "Это тестовый текст для проверки предобработки. https://example.com test@email.ru",
+        "Второй текст с эмодзи 😀 и HTML <p>тегами</p>.",
+        "Третий текст 123 с числами и ПРОПИСНЫМИ буквами!"
+    ]
+    
+    config = PreprocessingConfig(
+        lowercase=True,
+        remove_html=True,
+        remove_urls=True,
+        remove_emails=True,
+        lemmatize=False,  # Отключаем для теста
+        remove_stopwords=False
+    )
+    
+    preprocessor = TextPreprocessor(config)
+    processed = preprocessor.preprocess_batch(sample_texts)
+    
+    print("Обработанные тексты:")
+    for i, (orig, proc) in enumerate(zip(sample_texts, processed)):
+        print(f"\n{i+1}. Исходный: {orig[:50]}...")
+        print(f"   Обработанный: {proc[:50]}...")
+    
+    # Мета-признаки
+    meta_features = extract_meta_features(processed)
+    print(f"\nМета-признаки (форма: {meta_features.shape}):")
+    print(meta_features)
+

src/text_to_vector.py

@@ -0,0 +1,403 @@
+"""
+Модуль для векторизации текстов для кластеризации.
+Использует модели из ЛР2: Word2Vec, FastText, GloVe, а также TF-IDF и BM25.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import List, Dict, Any, Optional, Tuple
+import numpy as np
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.preprocessing import normalize
+
+try:
+    from rank_bm25 import BM25Okapi
+    BM25_AVAILABLE = True
+except ImportError:
+    BM25_AVAILABLE = False
+    print("⚠️ rank-bm25 не установлен. BM25 недоступен. Установите: pip install rank-bm25")
+
+from gensim.models import Word2Vec, FastText, Doc2Vec
+from gensim.utils import simple_preprocess
+
+from src.classical_vectorizers import ClassicalVectorizers, VectorizationConfig
+
+
+def load_embedding_model(model_path: str):
+    """
+    Загружает обученную модель эмбеддингов из ЛР2.
+    
+    Args:
+        model_path: Путь к модели
+    
+    Returns:
+        Загруженная модель (Word2Vec, FastText или Doc2Vec)
+    """
+    if not os.path.exists(model_path):
+        raise FileNotFoundError(f"Модель не найдена: {model_path}")
+    
+    # Пробуем загрузить как Word2Vec
+    try:
+        return Word2Vec.load(model_path)
+    except:
+        pass
+    
+    # Пробуем загрузить как FastText
+    try:
+        return FastText.load(model_path)
+    except:
+        pass
+    
+    # Пробуем загрузить как Doc2Vec
+    try:
+        return Doc2Vec.load(model_path)
+    except:
+        pass
+    
+    raise ValueError(f"Не удалось загрузить модель из {model_path}")
+
+
+def vectorize_tfidf(texts: List[str],
+                    max_features: Optional[int] = None,
+                    ngram_range: Tuple[int, int] = (1, 2),
+                    normalize_vectors: bool = True) -> Tuple[np.ndarray, Any]:
+    """
+    Векторизация текстов с помощью TF-IDF.
+    
+    Args:
+        texts: Список текстов
+        max_features: Максимальное количество признаков
+        ngram_range: Диапазон n-грамм
+        normalize_vectors: Нормализовать ли векторы (L2)
+    
+    Returns:
+        Матрица векторов и векторизатор
+    """
+    vectorizer = TfidfVectorizer(
+        max_features=max_features,
+        ngram_range=ngram_range,
+        lowercase=True,
+        min_df=1
+    )
+    
+    X = vectorizer.fit_transform(texts).toarray()
+    
+    if normalize_vectors:
+        X = normalize(X, norm='l2')
+    
+    return X, vectorizer
+
+
+def vectorize_bm25(texts: List[str],
+                  tokenize: bool = True) -> Tuple[np.ndarray, Any]:
+    """
+    Векторизация текстов с помощью BM25.
+    
+    Args:
+        texts: Список текстов
+        tokenize: Токенизировать ли тексты
+    
+    Returns:
+        Матрица векторов и BM25 объект
+    """
+    if not BM25_AVAILABLE:
+        raise ImportError("rank-bm25 не установлен. Установите: pip install rank-bm25")
+    
+    if tokenize:
+        tokenized_texts = [simple_preprocess(text, deacc=False, min_len=1) for text in texts]
+    else:
+        tokenized_texts = [text.split() for text in texts]
+    
+    bm25 = BM25Okapi(tokenized_texts)
+    
+    # Создаем матрицу BM25 для всех документов
+    X = np.array([bm25.get_scores(doc) for doc in tokenized_texts])
+    
+    # Нормализуем
+    X = normalize(X, norm='l2')
+    
+    return X, bm25
+
+
+def vectorize_with_word2vec(texts: List[str],
+                            model: Word2Vec,
+                            aggregation: str = "mean",
+                            normalize_vectors: bool = True) -> np.ndarray:
+    """
+    Векторизация текстов с помощью Word2Vec модели из ЛР2.
+    
+    Args:
+        texts: Список текстов
+        model: Обученная Word2Vec модель
+        aggregation: Метод агрегации (mean, max, sum)
+        normalize_vectors: Нормализовать ли векторы (L2)
+    
+    Returns:
+        Матрица векторов документов
+    """
+    kv = model.wv
+    vector_size = kv.vector_size
+    vectors = []
+    
+    for text in texts:
+        tokens = simple_preprocess(text, deacc=False, min_len=1)
+        word_vectors = []
+        
+        for token in tokens:
+            if token in kv:
+                word_vectors.append(kv[token])
+        
+        if not word_vectors:
+            vectors.append(np.zeros(vector_size))
+            continue
+        
+        word_vectors = np.array(word_vectors)
+        
+        if aggregation == "mean":
+            doc_vector = np.mean(word_vectors, axis=0)
+        elif aggregation == "max":
+            doc_vector = np.max(word_vectors, axis=0)
+        elif aggregation == "sum":
+            doc_vector = np.sum(word_vectors, axis=0)
+        else:
+            doc_vector = np.mean(word_vectors, axis=0)
+        
+        vectors.append(doc_vector)
+    
+    X = np.array(vectors)
+    
+    if normalize_vectors:
+        X = normalize(X, norm='l2')
+    
+    return X
+
+
+def vectorize_with_fasttext(texts: List[str],
+                           model: FastText,
+                           aggregation: str = "mean",
+                           normalize_vectors: bool = True) -> np.ndarray:
+    """
+    Векторизация текстов с помощью FastText модели из ЛР2.
+    
+    Args:
+        texts: Список текстов
+        model: Обученная FastText модель
+        aggregation: Метод агрегации (mean, max, sum)
+        normalize_vectors: Нормализовать ли векторы (L2)
+    
+    Returns:
+        Матрица векторов документов
+    """
+    kv = model.wv
+    vector_size = kv.vector_size
+    vectors = []
+    
+    for text in texts:
+        tokens = simple_preprocess(text, deacc=False, min_len=1)
+        word_vectors = []
+        
+        for token in tokens:
+            # FastText может обрабатывать OOV слова
+            if token in kv:
+                word_vectors.append(kv[token])
+            else:
+                # Получаем вектор для OOV слова
+                word_vectors.append(kv.get_vector(token))
+        
+        if not word_vectors:
+            vectors.append(np.zeros(vector_size))
+            continue
+        
+        word_vectors = np.array(word_vectors)
+        
+        if aggregation == "mean":
+            doc_vector = np.mean(word_vectors, axis=0)
+        elif aggregation == "max":
+            doc_vector = np.max(word_vectors, axis=0)
+        elif aggregation == "sum":
+            doc_vector = np.sum(word_vectors, axis=0)
+        else:
+            doc_vector = np.mean(word_vectors, axis=0)
+        
+        vectors.append(doc_vector)
+    
+    X = np.array(vectors)
+    
+    if normalize_vectors:
+        X = normalize(X, norm='l2')
+    
+    return X
+
+
+def vectorize_with_doc2vec(texts: List[str],
+                          model: Doc2Vec,
+                          normalize_vectors: bool = True) -> np.ndarray:
+    """
+    Векторизация текстов с помощью Doc2Vec модели из ЛР2.
+    
+    Args:
+        texts: Список текстов
+        model: Обученная Doc2Vec модель
+        normalize_vectors: Нормализовать ли векторы (L2)
+    
+    Returns:
+        Матрица векторов документов
+    """
+    vectors = []
+    
+    for text in texts:
+        tokens = simple_preprocess(text, deacc=False, min_len=1)
+        if tokens:
+            vec = model.infer_vector(tokens)
+        else:
+            vec = np.zeros(model.vector_size)
+        vectors.append(vec)
+    
+    X = np.array(vectors)
+    
+    if normalize_vectors:
+        X = normalize(X, norm='l2')
+    
+    return X
+
+
+def vectorize_with_glove(texts: List[str],
+                         model_path: str,
+                         aggregation: str = "mean",
+                         normalize_vectors: bool = True) -> np.ndarray:
+    """
+    Векторизация текстов с помощью GloVe модели из ЛР2.
+    
+    Примечание: GloVe обычно хранится в формате текстового файла или через gensim.
+    Здесь предполагается, что модель загружена через gensim или аналогичный интерфейс.
+    
+    Args:
+        texts: Список текстов
+        model_path: Путь к модели GloVe
+        aggregation: Метод агрегации (mean, max, sum)
+        normalize_vectors: Нормализовать ли векторы (L2)
+    
+    Returns:
+        Матрица векторов документов
+    """
+    # Пробуем загрузить как KeyedVectors (если сохранено через gensim)
+    try:
+        from gensim.models import KeyedVectors
+        kv = KeyedVectors.load(model_path)
+    except:
+        # Если не получилось, пробуем загрузить как Word2Vec (совместимость)
+        try:
+            model = Word2Vec.load(model_path)
+            kv = model.wv
+        except:
+            raise ValueError(f"Не удалось загрузить GloVe модель из {model_path}")
+    
+    vector_size = kv.vector_size
+    vectors = []
+    
+    for text in texts:
+        tokens = simple_preprocess(text, deacc=False, min_len=1)
+        word_vectors = []
+        
+        for token in tokens:
+            if token in kv:
+                word_vectors.append(kv[token])
+        
+        if not word_vectors:
+            vectors.append(np.zeros(vector_size))
+            continue
+        
+        word_vectors = np.array(word_vectors)
+        
+        if aggregation == "mean":
+            doc_vector = np.mean(word_vectors, axis=0)
+        elif aggregation == "max":
+            doc_vector = np.max(word_vectors, axis=0)
+        elif aggregation == "sum":
+            doc_vector = np.sum(word_vectors, axis=0)
+        else:
+            doc_vector = np.mean(word_vectors, axis=0)
+        
+        vectors.append(doc_vector)
+    
+    X = np.array(vectors)
+    
+    if normalize_vectors:
+        X = normalize(X, norm='l2')
+    
+    return X
+
+
+def vectorize_texts(texts: List[str],
+                   method: str = "tfidf",
+                   model_path: Optional[str] = None,
+                   **kwargs) -> Tuple[np.ndarray, Any]:
+    """
+    Универсальная функция векторизации текстов.
+    
+    Args:
+        texts: Список текстов
+        method: Метод векторизации (tfidf, bm25, w2v, fasttext, doc2vec, glove)
+        model_path: Путь к модели (для w2v, fasttext, doc2vec, glove)
+        **kwargs: Дополнительные параметры
+    
+    Returns:
+        Матрица векторов и объект векторизатора/модели
+    """
+    method = method.lower()
+    
+    if method == "tfidf":
+        return vectorize_tfidf(texts, **kwargs)
+    
+    elif method == "bm25":
+        return vectorize_bm25(texts, **kwargs)
+    
+    elif method == "w2v" or method == "word2vec":
+        if model_path is None:
+            raise ValueError("Для Word2Vec требуется model_path")
+        model = load_embedding_model(model_path)
+        X = vectorize_with_word2vec(texts, model, **kwargs)
+        return X, model
+    
+    elif method == "fasttext":
+        if model_path is None:
+            raise ValueError("Для FastText требуется model_path")
+        model = load_embedding_model(model_path)
+        X = vectorize_with_fasttext(texts, model, **kwargs)
+        return X, model
+    
+    elif method == "doc2vec" or method == "d2v":
+        if model_path is None:
+            raise ValueError("Для Doc2Vec требуется model_path")
+        model = load_embedding_model(model_path)
+        X = vectorize_with_doc2vec(texts, model, **kwargs)
+        return X, model
+    
+    elif method == "glove":
+        if model_path is None:
+            raise ValueError("Для GloVe требуется model_path")
+        X = vectorize_with_glove(texts, model_path, **kwargs)
+        return X, None
+    
+    else:
+        raise ValueError(f"Неизвестный метод векторизации: {method}")
+
+
+if __name__ == "__main__":
+    # Тестирование
+    sample_texts = [
+        "Это первый тестовый текст для проверки векторизации",
+        "Второй текст содержит другую информацию",
+        "Третий текст также используется для тестирования"
+    ]
+    
+    # TF-IDF
+    X_tfidf, vectorizer = vectorize_tfidf(sample_texts)
+    print(f"TF-IDF векторы: форма {X_tfidf.shape}")
+    
+    # BM25 (если доступен)
+    if BM25_AVAILABLE:
+        X_bm25, bm25 = vectorize_bm25(sample_texts)
+        print(f"BM25 векторы: форма {X_bm25.shape}")
+