feat: Вторая лабораторка

COMPLETED.md

@@ -90,3 +90,4 @@ NLP_Homework_1/
 **🎓 Лабораторная работа №1 выполнена успешно!**
 
 *Сравнительный анализ методов токенизации и нормализации текста на материале русскоязычных новостных корпусов*
+

REPORT.md

@@ -1,162 +0,0 @@
-# 📋 Отчет о выполнении лабораторной работы №1
-
-**Тема:** Сравнительный анализ методов токенизации и нормализации текста на материале русскоязычных новостных корпусов
-
-**Дата выполнения:** 2025-01-27
-
-## ✅ Выполненные задачи
-
-### 1. Формирование экспериментального корпуса текстов ✅
-- **Реализован модуль `scrapers.py`** для автоматического сбора данных
-- **Поддерживаемые источники:** lenta.ru, ria.ru, tass.ru, kommersant.ru, meduza.io
-- **Собран корпус:** 50,000+ слов из русскоязычных новостных источников
-- **Формат данных:** JSONL с полями url, title, text, date, category
-- **Функции:** RSS-парсинг, sitemap-сканирование, вежливые задержки, robots.txt
-
-### 2. Предварительная обработка и очистка текста ✅
-- **Создан модуль `text_cleaner.py`** для первичной очистки
-- **Функции:**
-  - Удаление HTML-разметки
-  - Стандартизация пробельных символов
-  - Удаление служебных символов
-  - Фильтрация стоп-слов (русский язык + новостные)
-  - Удаление коротких и числовых токенов
-- **Конфигурируемость:** параметры очистки настраиваются
-
-### 3. Универсальный модуль предобработки ✅
-- **Реализован `universal_preprocessor.py`** для стандартизации текста
-- **Возможности:**
-  - Замена URL, email, телефонов на унифицированные токены
-  - Раскрытие сокращений (т.е., г., ул., ООО, МВД и др.)
-  - Нормализация пунктуации и кавычек
-  - Стандартизация пробелов
-- **Конфигурируемость:** класс PreprocessingConfig для настройки
-
-### 4. Сравнительный анализ методов токенизации ✅
-- **Создан модуль `tokenizers_cmp.py`** для комплексного сравнения
-- **Поддерживаемые методы:**
-  - Наивная токенизация (по пробелам)
-  - Регулярные выражения
-  - Razdel (специально для русского языка)
-  - NLTK (word_tokenize)
-  - SpaCy (ru_core_news_sm)
-  - PyMorphy2 (лемматизация)
-  - Стемминг (Porter, Snowball)
-- **Метрики оценки:**
-  - Объем словаря
-  - Скорость обработки
-  - Коэффициент сжатия
-  - Средняя длина токена
-  - Разнообразие словаря
-
-### 5. Обучение подсловных моделей токенизации ✅
-- **Реализован модуль `train_subword.py`** для обучения моделей
-- **Поддерживаемые алгоритмы:**
-  - Byte Pair Encoding (BPE)
-  - WordPiece
-  - Unigram Language Model
-  - SentencePiece
-- **Параметры обучения:**
-  - Размер словаря: 8,000 – 32,000 токенов
-  - Минимальная частота: 2-5
-- **Метрики оценки:**
-  - Процент фрагментации слов
-  - Коэффициент сжатия
-  - Точность реконструкции
-  - Время обучения
-
-### 6. Веб-интерфейс для интерактивного анализа ✅
-- **Создано приложение `streamlit_app.py`** с полным функционалом
-- **Возможности:**
-  - Загрузка данных (файлы, примеры, корпус)
-  - Настройка предобработки и очистки
-  - Выбор методов токенизации для сравнения
-  - Интерактивная визуализация результатов
-  - Экспорт данных (CSV, JSON)
-- **Визуализация:**
-  - Сравнительные графики методов
-  - Распределение длин токенов
-  - Частотность токенов
-  - Статистика по методам
-
-### 7. Вспомогательные модули ✅
-- **Создан модуль `utils.py`** с утилитами:
-  - Работа с файлами (JSON, JSONL)
-  - Вычисление статистики текстов
-  - Создание графиков и визуализаций
-  - Валидация формата корпуса
-  - Форматирование времени и прогресс-бары
-
-## 📊 Результаты и выводы
-
-### Технические достижения:
-1. **Полнофункциональная система** анализа токенизации с веб-интерфейсом
-2. **Автоматизированный сбор данных** с соблюдением этических норм
-3. **Комплексное сравнение методов** с объективными метриками
-4. **Обучение подсловных моделей** с различными параметрами
-5. **Интерактивная визуализация** результатов анализа
-
-### Практическая ценность:
-- **Готовое решение** для анализа токенизации на русском языке
-- **Модульная архитектура** позволяет легко расширять функционал
-- **Веб-интерфейс** делает систему доступной для пользователей без технических навыков
-- **Документированный код** с примерами использования
-
-## 🚀 Инструкции по запуску
-
-### Установка зависимостей:
-```bash
-pip install -r requirements.txt
-```
-
-### Запуск веб-интерфейса:
-```bash
-streamlit run src/streamlit_app.py
-```
-
-### Демонстрация функционала:
-```bash
-python demo.py
-```
-
-### Сбор дополнительных данных:
-```bash
-python src/scrapers.py --auto --out data/raw_corpus.jsonl --min_words 50000
-```
-
-## 📁 Структура проекта
-
-```
-NLP_Homework_1/
-├── data/                    # Данные корпуса
-├── src/                     # Исходный код модулей
-├── models/                  # Обученные модели
-├── results/                 # Результаты анализа
-├── notebooks/               # Jupyter notebooks
-├── requirements.txt         # Зависимости
-├── demo.py                 # Демонстрационный скрипт
-└── README.md               # Документация
-```
-
-## 🎯 Соответствие требованиям задания
-
-✅ **Этап 1:** Формирование корпуса (50k+ слов)  
-✅ **Этап 2:** Предобработка и очистка текста  
-✅ **Этап 3:** Универсальный модуль предобработки  
-✅ **Этап 4:** Сравнительный анализ методов токенизации  
-✅ **Этап 5:** Обучение подсловных моделей  
-✅ **Этап 6:** Веб-интерфейс для интерактивного анализа  
-⏳ **Этап 7:** Публикация моделей в Hugging Face Hub (опционально)
-
-## 💡 Рекомендации по использованию
-
-1. **Для быстрого старта** используйте веб-интерфейс Streamlit
-2. **Для глубокого анализа** запускайте модули программно
-3. **Для расширения функционала** добавляйте новые методы в соответствующие модули
-4. **Для production** рассмотрите оптимизацию производительности
-
-## 📝 Заключение
-
-Лабораторная работа выполнена в полном объеме. Создана комплексная система для анализа методов токенизации и нормализации текста на русском языке, включающая все требуемые компоненты и дополнительные возможности для удобства использования.
-
-Система готова к использованию и может служить основой для дальнейших исследований в области обработки естественного языка.

STATISTICS_FIX_EXPLANATION.md

@@ -98,3 +98,4 @@ st.metric("Всего токенов", total_tokens)  # Теперь прави
 - ✅ **Разнообразие словаря** - стало реалистичным
 
 **Теперь веб-интерфейс работает правильно!** 🎊
+

TOKENIZATION_EXPLANATION.md

@@ -63,3 +63,4 @@ def tokenize_words_only(text):
 - **Для быстрого анализа**: используйте `naive`
 
 **Токенизация работает корректно!** 🎉
+

requirements.txt

@@ -11,10 +11,16 @@ streamlit
 matplotlib
 plotly
 scikit-learn
+scipy
 feedparser
 seaborn
 wordcloud
 tqdm
+# ЛР2 — векторизация и эмбеддинги
+gensim
+umap-learn
+# fasttext  # опционально, требует системную установку
+# glove-python-binary  # опционально
 # pymorphy2  # Несовместим с Python 3.13+
 # transformers  # Удалено по запросу пользователя
 # torch  # Удалено по запросу пользователя

results/vectorization_metrics.csv

@@ -0,0 +1,3 @@
+Метод,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

run.sh

@@ -1,9 +1,7 @@
 #!/usr/bin/env bash
 # -*- coding: utf-8 -*-
-"""
-Скрипт для быстрого запуска системы анализа токенизации.
-Автоматически устанавливает зависимости и запускает веб-интерфейс.
-"""
+# Скрипт для быстрого запуска системы анализа токенизации.
+# Автоматически устанавливает зависимости и запускает веб-интерфейс.
 
 echo "🚀 Запуск системы анализа токенизации"
 echo "====================================="
@@ -98,4 +96,5 @@ esac
 echo ""
 echo "✅ Работа завершена!"
 echo "📖 Документация: README.md"
-echo "📋 Отчет: REPORT.md"
+echo "📋 Отчет: FINAL_REPORT.md"
+

src/classical_vectorizers.py

@@ -0,0 +1,214 @@
+"""
+Классические методы векторизации текста: One-Hot, Bag-of-Words, TF-IDF с поддержкой n-грамм.
+Предоставляет единый интерфейс fit/transform, вычисление метрик разреженности и размерности,
+а также удобные функции для сравнения конфигураций и экспорта результатов.
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Tuple, Any
+
+import numpy as np
+import pandas as pd
+from scipy import sparse
+from sklearn.feature_extraction import DictVectorizer
+from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
+
+
+@dataclass
+class VectorizationConfig:
+    method: str  # onehot | bow | tfidf
+    ngram_range: Tuple[int, int] = (1, 1)
+    lowercase: bool = True
+    min_df: int | float = 1
+    max_df: int | float = 1.0
+    max_features: Optional[int] = None
+    analyzer: str = "word"  # word | char | char_wb
+    smooth_idf: bool = True  # для TF-IDF
+    sublinear_tf: bool = False  # для TF-IDF
+
+
+@dataclass
+class VectorizationReport:
+    method_name: str
+    ngram_range: str
+    num_docs: int
+    num_features: int
+    nnz: int
+    density: float
+    build_time_sec: float
+    transform_time_sec: float
+    memory_estimate_mb: float
+
+
+class ClassicalVectorizers:
+    """Универсальный интерфейс для классических векторизаторов текста."""
+
+    def __init__(self, config: VectorizationConfig):
+        self.config = config
+        self.vectorizer = self._create_vectorizer(config)
+
+    def _create_vectorizer(self, config: VectorizationConfig):
+        method = config.method.lower()
+
+        if method == "bow":
+            return CountVectorizer(
+                ngram_range=config.ngram_range,
+                lowercase=config.lowercase,
+                min_df=config.min_df,
+                max_df=config.max_df,
+                max_features=config.max_features,
+                analyzer=config.analyzer,
+            )
+
+        if method == "tfidf":
+            return TfidfVectorizer(
+                ngram_range=config.ngram_range,
+                lowercase=config.lowercase,
+                min_df=config.min_df,
+                max_df=config.max_df,
+                max_features=config.max_features,
+                analyzer=config.analyzer,
+                smooth_idf=config.smooth_idf,
+                sublinear_tf=config.sublinear_tf,
+            )
+
+        if method == "onehot":
+            # Реализуем через словари токенов -> 1 и DictVectorizer
+            return DictVectorizer(sparse=True)
+
+        raise ValueError(f"Неизвестный метод векторизации: {config.method}")
+
+    @staticmethod
+    def _texts_to_onehot_dicts(texts: List[str], ngram_range: Tuple[int, int]) -> List[Dict[str, int]]:
+        """Преобразует тексты в словари признаков для one-hot (включая n-граммы)."""
+        def extract_ngrams(tokens: List[str], n: int) -> List[str]:
+            return ["_".join(tokens[i : i + n]) for i in range(len(tokens) - n + 1)]
+
+        dicts: List[Dict[str, int]] = []
+        n_min, n_max = ngram_range
+        for text in texts:
+            tokens = text.split()
+            features: Dict[str, int] = {}
+            for n in range(n_min, n_max + 1):
+                if n == 1:
+                    grams = tokens
+                else:
+                    grams = extract_ngrams(tokens, n)
+                for g in grams:
+                    features[g] = 1
+            dicts.append(features)
+        return dicts
+
+    @staticmethod
+    def _sparsity_metrics(X: sparse.spmatrix) -> Tuple[int, int, float, float]:
+        nnz = int(X.nnz)
+        num_docs, num_features = X.shape
+        total = num_docs * num_features
+        density = (nnz / total) if total > 0 else 0.0
+        mem_bytes = (nnz * (8 + 8 + 8))  # грубая оценка COO/CSR: data+indices+indptr
+        mem_mb = mem_bytes / (1024**2)
+        return num_features, nnz, density, mem_mb
+
+    def fit_transform(self, texts: List[str]) -> Tuple[sparse.spmatrix, VectorizationReport]:
+        start = time.time()
+
+        if isinstance(self.vectorizer, DictVectorizer):
+            dicts = self._texts_to_onehot_dicts(texts, self.config.ngram_range)
+            X = self.vectorizer.fit_transform(dicts)
+        else:
+            X = self.vectorizer.fit_transform(texts)
+
+        build_time = time.time() - start
+        # Дополнительное преобразование для оценки времени transform
+        t0 = time.time()
+        if isinstance(self.vectorizer, DictVectorizer):
+            _ = self.vectorizer.transform(dicts)
+        else:
+            _ = self.vectorizer.transform(texts)
+        transform_time = time.time() - t0
+
+        num_features, nnz, density, mem_mb = self._sparsity_metrics(X)
+
+        report = VectorizationReport(
+            method_name=self.config.method,
+            ngram_range=f"{self.config.ngram_range[0]}-{self.config.ngram_range[1]}",
+            num_docs=len(texts),
+            num_features=num_features,
+            nnz=nnz,
+            density=round(density, 6),
+            build_time_sec=round(build_time, 4),
+            transform_time_sec=round(transform_time, 4),
+            memory_estimate_mb=round(mem_mb, 2),
+        )
+        return X, report
+
+    def transform(self, texts: List[str]) -> sparse.spmatrix:
+        if isinstance(self.vectorizer, DictVectorizer):
+            dicts = self._texts_to_onehot_dicts(texts, self.config.ngram_range)
+            return self.vectorizer.transform(dicts)
+        return self.vectorizer.transform(texts)
+
+    def get_feature_names(self) -> List[str]:
+        if hasattr(self.vectorizer, "get_feature_names_out"):
+            return list(self.vectorizer.get_feature_names_out())
+        if hasattr(self.vectorizer, "feature_names_"):
+            return list(self.vectorizer.feature_names_)
+        return []
+
+
+def compare_vectorizers(
+    texts: List[str],
+    configs: List[VectorizationConfig],
+) -> Tuple[pd.DataFrame, Dict[str, Any]]:
+    """
+    Сравнивает несколько конфигураций векторизации и возвращает таблицу метрик.
+    Дополнительно возвращает словарь с матрицами признаков по ключу <method|ngram>.
+    """
+    results: List[VectorizationReport] = []
+    matrices: Dict[str, Any] = {}
+
+    for cfg in configs:
+        vec = ClassicalVectorizers(cfg)
+        X, rep = vec.fit_transform(texts)
+        key = f"{cfg.method}:{cfg.ngram_range}"
+        matrices[key] = {"X": X, "vectorizer": vec}
+        results.append(rep)
+
+    df = pd.DataFrame([
+        {
+            "Метод": r.method_name,
+            "N-граммы": r.ngram_range,
+            "Документов": r.num_docs,
+            "Признаков": r.num_features,
+            "Ненулевых": r.nnz,
+            "Плотность": r.density,
+            "Время fit (с)": r.build_time_sec,
+            "Время transform (с)": r.transform_time_sec,
+            "Память (MB) ~": r.memory_estimate_mb,
+        }
+        for r in results
+    ])
+    return df.sort_values(["Метод", "N-граммы"]).reset_index(drop=True), matrices
+
+
+def save_metrics(df: pd.DataFrame, output_csv: str) -> None:
+    df.to_csv(output_csv, index=False, encoding="utf-8")
+
+
+if __name__ == "__main__":
+    sample = [
+        "Россия и Франция подписали новое соглашение по энергетике.",
+        "Путин встретился с президентом Турции и обсудил поставки газа.",
+        "В Москве пройдут переговоры министров иностранных дел.",
+    ]
+    configs = [
+        VectorizationConfig(method="onehot", ngram_range=(1, 1)),
+        VectorizationConfig(method="bow", ngram_range=(1, 2)),
+        VectorizationConfig(method="tfidf", ngram_range=(1, 3), sublinear_tf=True),
+    ]
+    df, _ = compare_vectorizers(sample, configs)
+    print(df)
+

src/dimensionality.py

@@ -0,0 +1,88 @@
+"""
+Снижение размерности и тематическое моделирование для классических векторных представлений.
+Поддерживаются: TruncatedSVD (LSA), визуализация UMAP/t-SNE, анализ объясненной дисперсии
+и интерпретация компонент через топ-термины.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List, Tuple, Dict, Any, Optional
+
+import numpy as np
+import pandas as pd
+from sklearn.decomposition import TruncatedSVD
+from sklearn.manifold import TSNE
+
+try:
+    import umap  # type: ignore
+    UMAP_AVAILABLE = True
+except Exception:
+    UMAP_AVAILABLE = False
+
+
+@dataclass
+class SVDConfig:
+    n_components: int = 100
+    random_state: int = 42
+
+
+def run_lsa(X, feature_names: List[str], config: SVDConfig) -> Dict[str, Any]:
+    """
+    Выполняет LSA (TruncatedSVD) и возвращает компоненты, объясненную дисперсию
+    и топ-термины для каждой компоненты.
+    """
+    svd = TruncatedSVD(n_components=config.n_components, random_state=config.random_state)
+    X_reduced = svd.fit_transform(X)
+
+    explained = svd.explained_variance_ratio_
+    cumulative = np.cumsum(explained)
+
+    # Топ-термины на компоненту
+    components = svd.components_
+    top_terms_per_component: List[List[Tuple[str, float]]] = []
+    for comp in components:
+        idx = np.argsort(-np.abs(comp))[:20]
+        top_terms_per_component.append([(feature_names[i], float(comp[i])) for i in idx])
+
+    return {
+        "svd": svd,
+        "X_reduced": X_reduced,
+        "explained_variance_ratio": explained,
+        "explained_variance_ratio_cum": cumulative,
+        "top_terms_per_component": top_terms_per_component,
+    }
+
+
+def embed_2d(X, method: str = "umap", random_state: int = 42, n_neighbors: int = 15, min_dist: float = 0.1):
+    """Проецирует матрицу признаков/векторов в 2D для визуализации (UMAP или t-SNE)."""
+    if method == "umap":
+        if not UMAP_AVAILABLE:
+            raise ImportError("umap-learn не установлен")
+        reducer = umap.UMAP(n_components=2, random_state=random_state, n_neighbors=n_neighbors, min_dist=min_dist)
+        return reducer.fit_transform(X)
+
+    if method == "tsne":
+        tsne = TSNE(n_components=2, random_state=random_state, init="pca", learning_rate="auto")
+        return tsne.fit_transform(X)
+
+    raise ValueError("method должен быть 'umap' или 'tsne'")
+
+
+def explained_variance_table(explained_ratio: np.ndarray) -> pd.DataFrame:
+    cum = np.cumsum(explained_ratio)
+    return pd.DataFrame({
+        "Компонента": np.arange(1, len(explained_ratio) + 1),
+        "Доля дисперсии": np.round(explained_ratio, 6),
+        "Накопленная доля": np.round(cum, 6),
+    })
+
+
+def top_terms_dataframe(top_terms: List[List[Tuple[str, float]]], top_k: int = 10) -> pd.DataFrame:
+    rows = []
+    for comp_idx, terms in enumerate(top_terms):
+        for term, weight in terms[:top_k]:
+            rows.append({"Компонента": comp_idx + 1, "Термин": term, "Вес": float(weight)})
+    return pd.DataFrame(rows)
+
+

src/embeddings_train.py

@@ -0,0 +1,195 @@
+"""
+Обучение распределённых представлений: Word2Vec (CBOW/Skip-gram), FastText (cbow/skipgram), Doc2Vec (PV-DM/PV-DBOW).
+Предоставляет единый интерфейс обучения, сохранения, загрузки и базовых оценок.
+"""
+
+from __future__ import annotations
+
+import os
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable, List, Optional, Tuple, Dict, Any
+
+import numpy as np
+import pandas as pd
+from gensim.models import Word2Vec, FastText, Doc2Vec
+from gensim.models.doc2vec import TaggedDocument
+from gensim.utils import simple_preprocess
+
+
+@dataclass
+class TrainConfig:
+    model_type: str  # w2v | fasttext | doc2vec
+    vector_size: int = 300
+    window: int = 8
+    min_count: int = 2
+    sg: int = 1  # 0=CBOW, 1=Skip-gram для w2v/fasttext; для doc2vec игнорируется
+    dm: int = 1  # 1=PV-DM, 0=PV-DBOW для doc2vec
+    epochs: int = 10
+    workers: int = 4
+    negative: int = 5
+    hs: int = 0
+    seed: int = 42
+
+
+def _tokenize_corpus(texts: Iterable[str]) -> List[List[str]]:
+    return [simple_preprocess(t, deacc=False, min_len=1) for t in texts]
+
+
+def train_word2vec(texts: Iterable[str], cfg: TrainConfig) -> Word2Vec:
+    sentences = _tokenize_corpus(texts)
+    model = Word2Vec(
+        vector_size=cfg.vector_size,
+        window=cfg.window,
+        min_count=cfg.min_count,
+        sg=cfg.sg,
+        workers=cfg.workers,
+        negative=cfg.negative,
+        hs=cfg.hs,
+        seed=cfg.seed,
+    )
+    model.build_vocab(sentences)
+    # Если словарь пуст из-за min_count — понижаем порог и повторяем
+    if len(model.wv) == 0 and cfg.min_count > 1:
+        model.min_count = 1
+        model.build_vocab(sentences, update=False)
+    if len(model.wv) == 0:
+        return model  # вернем пустую модель; UI отобразит, что соседей нет
+    model.train(sentences, total_examples=len(sentences), epochs=cfg.epochs)
+    return model
+
+
+def train_fasttext(texts: Iterable[str], cfg: TrainConfig) -> FastText:
+    sentences = _tokenize_corpus(texts)
+    model = FastText(
+        vector_size=cfg.vector_size,
+        window=cfg.window,
+        min_count=cfg.min_count,
+        sg=cfg.sg,
+        workers=cfg.workers,
+        negative=cfg.negative,
+        hs=cfg.hs,
+        seed=cfg.seed,
+    )
+    model.build_vocab(sentences)
+    if len(model.wv) == 0 and cfg.min_count > 1:
+        model.min_count = 1
+        model.build_vocab(sentences, update=False)
+    if len(model.wv) == 0:
+        return model
+    model.train(sentences, total_examples=len(sentences), epochs=cfg.epochs)
+    return model
+
+
+def train_doc2vec(texts: Iterable[str], cfg: TrainConfig) -> Doc2Vec:
+    tagged = [TaggedDocument(simple_preprocess(t), [i]) for i, t in enumerate(texts)]
+    model = Doc2Vec(
+        vector_size=cfg.vector_size,
+        window=cfg.window,
+        min_count=cfg.min_count,
+        dm=cfg.dm,
+        workers=cfg.workers,
+        negative=cfg.negative,
+        hs=cfg.hs,
+        seed=cfg.seed,
+    )
+    model.build_vocab(tagged)
+    if len(model.wv) == 0 and cfg.min_count > 1:
+        model.min_count = 1
+        model.build_vocab(tagged, update=False)
+    if len(model.wv) == 0:
+        return model
+    model.train(tagged, total_examples=len(tagged), epochs=cfg.epochs)
+    return model
+
+
+def train_model(texts: Iterable[str], cfg: TrainConfig):
+    t0 = time.time()
+    if cfg.model_type == "w2v":
+        model = train_word2vec(texts, cfg)
+    elif cfg.model_type == "fasttext":
+        model = train_fasttext(texts, cfg)
+    elif cfg.model_type == "doc2vec":
+        model = train_doc2vec(texts, cfg)
+    else:
+        raise ValueError("model_type должен быть 'w2v', 'fasttext' или 'doc2vec'")
+    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)
+
+
+def load_model(path: str):
+    # gensim сам определит тип по расширению/классу
+    from gensim.models import Word2Vec as _W2V, FastText as _FT, Doc2Vec as _D2V
+    try:
+        return _W2V.load(path)
+    except Exception:
+        pass
+    try:
+        return _FT.load(path)
+    except Exception:
+        pass
+    return _D2V.load(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] = []
+    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))
+    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 []
+
+
+def export_training_report(cfg: TrainConfig, train_time: float, model_path: str, extra: Optional[Dict[str, Any]] = None) -> pd.DataFrame:
+    data = {
+        "Модель": cfg.model_type,
+        "Размерность": cfg.vector_size,
+        "Окно": cfg.window,
+        "Min count": cfg.min_count,
+        "Архитектура": ("skipgram" if cfg.sg == 1 else "cbow") if cfg.model_type in {"w2v", "fasttext"} else ("pv-dm" if cfg.dm == 1 else "pv-dbow"),
+        "Эпохи": cfg.epochs,
+        "Время обучения (с)": round(train_time, 2),
+        "Путь": model_path,
+    }
+    if extra:
+        data.update(extra)
+    return pd.DataFrame([data])
+
+
+if __name__ == "__main__":
+    texts = [
+        "Москва является столицей России.",
+        "Париж — столица Франции.",
+        "Берлин — столица Германии.",
+    ]
+    cfg = TrainConfig(model_type="w2v", vector_size=100, window=5, epochs=5, sg=1)
+    model, tt = train_model(texts, cfg)
+    save_model(model, "models/sample_w2v.model")
+    print(evaluate_neighbors(model, ["россии", "франции"]))
+

src/semantic_experiments.py

@@ -0,0 +1,89 @@
+"""
+Семантические эксперименты с эмбеддингами: косинусное сходство, аналогии, семантические оси,
+качественный анализ ближайших соседей и построение матриц близости.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, List, Tuple
+import numpy as np
+import pandas as pd
+
+
+def cosine(u: np.ndarray, v: np.ndarray) -> float:
+    nu = np.linalg.norm(u)
+    nv = np.linalg.norm(v)
+    if nu == 0 or nv == 0:
+        return float("nan")
+    return float(np.dot(u, v) / (nu * nv))
+
+
+def pairwise_cosine_matrix(vectors: Dict[str, np.ndarray]) -> pd.DataFrame:
+    keys = list(vectors.keys())
+    mat = np.zeros((len(keys), len(keys)), dtype=float)
+    for i, ki in enumerate(keys):
+        for j, kj in enumerate(keys):
+            mat[i, j] = cosine(vectors[ki], vectors[kj])
+    return pd.DataFrame(mat, index=keys, columns=keys)
+
+
+def vector_arithmetic(model, expression: str, topn: int = 10) -> List[Tuple[str, float]]:
+    """
+    Вычисляет выражения вида "король - мужчина + женщина" и возвращает ближайшие слова.
+    """
+    kv = model.wv if hasattr(model, "wv") else model
+
+    tokens = expression.replace("+", " + ").replace("-", " - ").split()
+    positives: List[str] = []
+    negatives: List[str] = []
+    sign = 1
+    for tok in tokens:
+        if tok == "+":
+            sign = 1
+        elif tok == "-":
+            sign = -1
+        else:
+            if sign == 1:
+                positives.append(tok)
+            else:
+                negatives.append(tok)
+    if not positives:
+        return []
+    try:
+        return kv.most_similar(positive=positives, negative=negatives, topn=topn)
+    except KeyError:
+        return []
+
+
+def semantic_axis(model, a: str, b: str, words: List[str]) -> pd.DataFrame:
+    """
+    Строит семантическую ось (a->b) и проецирует заданные слова на эту ось.
+    Возвращает DataFrame с координатами проекции.
+    """
+    kv = model.wv if hasattr(model, "wv") else model
+    if a not in kv or b not in kv:
+        return pd.DataFrame(columns=["слово", "проекция"])
+    axis = kv[b] - kv[a]
+    axis_norm = axis / (np.linalg.norm(axis) + 1e-9)
+
+    rows = []
+    for w in words:
+        if w in kv:
+            proj = float(np.dot(kv[w], axis_norm))
+        else:
+            proj = np.nan
+        rows.append({"слово": w, "проекция": proj})
+    return pd.DataFrame(rows)
+
+
+def nearest_neighbors(model, words: List[str], topn: int = 10) -> Dict[str, List[Tuple[str, float]]]:
+    kv = model.wv if hasattr(model, "wv") else model
+    out: Dict[str, List[Tuple[str, float]]] = {}
+    for w in words:
+        if w in kv:
+            out[w] = kv.most_similar(w, topn=topn)
+        else:
+            out[w] = []
+    return out
+
+

src/streamlit_app.py

@@ -32,6 +32,15 @@ from src.text_cleaner import clean_text, clean_corpus_jsonl
 from src.universal_preprocessor import UniversalPreprocessor, PreprocessingConfig
 from src.tokenizers_cmp import TokenizationComparator, load_corpus_from_jsonl
 from src.train_subword import SubwordModelTrainer, SubwordModelConfig
+from src.classical_vectorizers import (
+    VectorizationConfig,
+    ClassicalVectorizers,
+    compare_vectorizers,
+    save_metrics as save_vectorization_metrics,
+)
+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
 
 
 # Настройка страницы
@@ -284,187 +293,292 @@ def main():
         st.info("💡 Используйте боковую панель для загрузки файла или выберите примеры.")
         return
     
-    # Применяем предобработку и очистку
+    # Сохраняем исходные тексты и метаданные источника
+    raw_texts = list(texts)
+    st.session_state["data_meta"] = {
+        "source": data_source,
+        "num_texts": len(raw_texts),
+    }
+
+    # Применяем предобработку и очистку, параллельно сохраняя обе версии
+    processed_texts = list(raw_texts)
     if use_preprocessing:
         config = PreprocessingConfig(**preprocessing_options)
         preprocessor = UniversalPreprocessor(config)
-        
-        processed_texts = []
-        for text in texts:
+        tmp = []
+        for text in raw_texts:
             processed_text = preprocessor.preprocess(text)
             processed_text = clean_text(processed_text, **cleaning_options)
-            processed_texts.append(processed_text)
-        texts = processed_texts
-    
-    # Выбор методов токенизации
-    st.subheader("🎯 Методы токенизации")
-    
-    comparator = TokenizationComparator()
-    available_methods = list(comparator.methods.keys())
-    
-    selected_methods = st.multiselect(
-        "Выберите методы для сравнения:",
-        available_methods,
-        default=available_methods[:3] if len(available_methods) >= 3 else available_methods
-    )
-    
-    if not selected_methods:
-        st.warning("⚠️ Пожалуйста, выберите хотя бы один метод токенизации.")
-        return
-    
-    # Кнопка запуска анализа
-    if st.button("🚀 Запустить анализ", type="primary"):
-        
-        with st.spinner("Выполняется анализ..."):
-            # Сравниваем методы
-            results_df = comparator.compare_methods(texts, selected_methods)
-            
-            # Сохраняем результаты в сессии
-            st.session_state['results_df'] = results_df
-            st.session_state['texts'] = texts
-            st.session_state['selected_methods'] = selected_methods
+            tmp.append(processed_text)
+        processed_texts = tmp
+
+    # Положим обе версии в состояние для явного выбора на вкладках
+    st.session_state["raw_texts"] = raw_texts
+    st.session_state["processed_texts"] = processed_texts
+    texts = processed_texts
     
-    # Отображение результатов
-    if 'results_df' in st.session_state:
-        results_df = st.session_state['results_df']
-        texts = st.session_state['texts']
-        selected_methods = st.session_state['selected_methods']
-        
-        # Общая статистика
-        st.subheader("📊 Общая статистика")
-        
-        col1, col2, col3, col4 = st.columns(4)
-        
-        with col1:
-            st.metric("Количество текстов", len(texts))
-        
-        with col2:
-            total_words = sum(len(text.split()) for text in texts)
-            st.metric("Общее количество слов", total_words)
-        
-        with col3:
-            avg_words_per_text = total_words / len(texts) if texts else 0
-            st.metric("Среднее слов на текст", round(avg_words_per_text, 1))
-        
-        with col4:
-            st.metric("Проанализировано методов", len(selected_methods))
-        
-        # Таблица результатов
-        st.subheader("📋 Результаты сравнения")
-        st.dataframe(results_df, use_container_width=True)
-        
-        # Графики сравнения
-        st.subheader("📈 Визуализация результатов")
-        
-        comparison_chart = create_comparison_chart(results_df)
-        st.plotly_chart(comparison_chart, use_container_width=True)
-        
-        # Детальный анализ для каждого метода
-        st.subheader("🔍 Детальный анализ методов")
-        
-        method_tabs = st.tabs(selected_methods)
-        
-        for i, method in enumerate(selected_methods):
-            with method_tabs[i]:
-                # Анализируем все тексты для получения полной статистики
-                if texts:
-                    # Анализируем все тексты
-                    all_tokens = []
-                    total_processing_time = 0
-                    
-                    for text in texts:
-                        tokens, processing_time = comparator.tokenize_text(text, method)
-                        all_tokens.extend(tokens)
-                        total_processing_time += processing_time
-                    
-                    # Используем первый текст для демонстрации
-                    sample_text = texts[0]
-                    sample_tokens, _ = comparator.tokenize_text(sample_text, method)
-                    
-                    col1, col2 = st.columns(2)
-                    
-                    with col1:
-                        st.write("**Исходный текст:**")
-                        st.text(sample_text[:200] + "..." if len(sample_text) > 200 else sample_text)
-                    
-                    with col2:
-                        st.write("**Токены (пример из первого текста):**")
-                        st.write(sample_tokens[:20])  # Показываем первые 20 токенов
-                        if len(sample_tokens) > 20:
-                            st.write(f"... и еще {len(sample_tokens) - 20} токенов")
-                    
-                    # Графики распределения
-                    col1, col2 = st.columns(2)
-                    
-                    with col1:
-                        dist_plot = create_token_distribution_plot(all_tokens, method)
-                        st.plotly_chart(dist_plot, use_container_width=True)
-                    
-                    with col2:
-                        freq_plot = create_frequency_plot(all_tokens, method)
-                        st.plotly_chart(freq_plot, use_container_width=True)
-                    
-                    # Статистика по методу (для всех текстов)
-                    from collections import Counter
-                    token_counts = Counter(all_tokens)
-                    unique_tokens = len(token_counts)
-                    total_tokens = len(all_tokens)
-                    vocabulary_diversity = unique_tokens / total_tokens if total_tokens > 0 else 0
-                    
-                    st.write("**Статистика:**")
-                    col1, col2, col3, col4 = st.columns(4)
-                    
-                    with col1:
-                        st.metric("Всего токенов", total_tokens)
-                    
-                    with col2:
-                        st.metric("Уникальных токенов", unique_tokens)
-                    
-                    with col3:
-                        st.metric("Разнообразие словаря", f"{vocabulary_diversity:.2%}")
-                    
-                    with col4:
-                        st.metric("Время обработки", f"{total_processing_time:.4f}с")
-        
-        # Экспорт результатов
-        st.subheader("💾 Экспорт результатов")
-        
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            # CSV экспорт
-            csv_data = results_df.to_csv(index=False, encoding='utf-8')
-            st.download_button(
-                label="📥 Скачать CSV",
-                data=csv_data,
-                file_name="tokenization_results.csv",
-                mime="text/csv"
+    # Главные вкладки ЛР1/ЛР2
+    main_tabs = st.tabs(["Токенизация", "Векторизация", "Эмбеддинги"])
+
+    # ======== Токенизация (ЛР1) ========
+    with main_tabs[0]:
+        st.subheader("🎯 Методы токенизации")
+        comparator = TokenizationComparator()
+        available_methods = list(comparator.methods.keys())
+        selected_methods = st.multiselect(
+            "Выберите методы для сравнения:",
+            available_methods,
+            default=available_methods[:3] if len(available_methods) >= 3 else available_methods
+        )
+        if not selected_methods:
+            st.warning("⚠️ Пожалуйста, выберите хотя бы один метод токенизации.")
+            st.stop()
+
+        if st.button("🚀 Запустить а��ализ", type="primary"):
+            with st.spinner("Выполняется анализ..."):
+                results_df = comparator.compare_methods(texts, selected_methods)
+                st.session_state['results_df'] = results_df
+                st.session_state['texts'] = texts
+                st.session_state['selected_methods'] = selected_methods
+
+        if 'results_df' in st.session_state:
+            results_df = st.session_state['results_df']
+            texts = st.session_state['texts']
+            selected_methods = st.session_state['selected_methods']
+
+            st.subheader("📊 Общая статистика")
+            col1, col2, col3, col4 = st.columns(4)
+            with col1:
+                st.metric("Количество текстов", len(texts))
+            with col2:
+                total_words = sum(len(text.split()) for text in texts)
+                st.metric("Общее количество слов", total_words)
+            with col3:
+                avg_words_per_text = total_words / len(texts) if texts else 0
+                st.metric("Среднее слов на текст", round(avg_words_per_text, 1))
+            with col4:
+                st.metric("Проанализировано методов", len(selected_methods))
+
+            st.subheader("📋 Результаты сравнения")
+            st.dataframe(results_df, use_container_width=True)
+
+            st.subheader("📈 Визуализация результатов")
+            comparison_chart = create_comparison_chart(results_df)
+            st.plotly_chart(comparison_chart, use_container_width=True)
+
+            st.subheader("🔍 Детальный анализ методов")
+            method_tabs = st.tabs(selected_methods)
+            for i, method in enumerate(selected_methods):
+                with method_tabs[i]:
+                    if texts:
+                        all_tokens = []
+                        total_processing_time = 0
+                        for text in texts:
+                            tokens, processing_time = comparator.tokenize_text(text, method)
+                            all_tokens.extend(tokens)
+                            total_processing_time += processing_time
+                        sample_text = texts[0]
+                        sample_tokens, _ = comparator.tokenize_text(sample_text, method)
+                        col1, col2 = st.columns(2)
+                        with col1:
+                            st.write("**Исходный текст:**")
+                            st.text(sample_text[:200] + "..." if len(sample_text) > 200 else sample_text)
+                        with col2:
+                            st.write("**Токены (пример из первого текста):**")
+                            st.write(sample_tokens[:20])
+                            if len(sample_tokens) > 20:
+                                st.write(f"... и еще {len(sample_tokens) - 20} токенов")
+                        col1, col2 = st.columns(2)
+                        with col1:
+                            dist_plot = create_token_distribution_plot(all_tokens, method)
+                            st.plotly_chart(dist_plot, use_container_width=True)
+                        with col2:
+                            freq_plot = create_frequency_plot(all_tokens, method)
+                            st.plotly_chart(freq_plot, use_container_width=True)
+                        from collections import Counter
+                        token_counts = Counter(all_tokens)
+                        unique_tokens = len(token_counts)
+                        total_tokens = len(all_tokens)
+                        vocabulary_diversity = unique_tokens / total_tokens if total_tokens > 0 else 0
+                        st.write("**Статистика:**")
+                        col1, col2, col3, col4 = st.columns(4)
+                        with col1:
+                            st.metric("Всего токенов", total_tokens)
+                        with col2:
+                            st.metric("Уникальных токенов", unique_tokens)
+                        with col3:
+                            st.metric("Разнообразие словаря", f"{vocabulary_diversity:.2%}")
+                        with col4:
+                            st.metric("Время обработки", f"{total_processing_time:.4f}с")
+
+            st.subheader("💾 Экспорт результатов")
+            col1, col2 = st.columns(2)
+            with col1:
+                csv_data = results_df.to_csv(index=False, encoding='utf-8')
+                st.download_button(
+                    label="📥 Скачать CSV",
+                    data=csv_data,
+                    file_name="tokenization_results.csv",
+                    mime="text/csv"
+                )
+            with col2:
+                json_data = results_df.to_json(orient='records', force_ascii=False, indent=2)
+                st.download_button(
+                    label="📥 Скачать JSON",
+                    data=json_data,
+                    file_name="tokenization_results.json",
+                    mime="application/json"
+                )
+
+    # ======== Векторизация (ЛР2: классика + LSA) ========
+    with main_tabs[1]:
+        st.subheader("🧮 Классические методы векторизации")
+        with st.expander("Параметры векторизации", expanded=True):
+            methods = st.multiselect("Методы", ["onehot", "bow", "tfidf"], default=["bow", "tfidf"])
+            n_min = st.number_input("n-gram min", 1, 5, 1)
+            n_max = st.number_input("n-gram max", 1, 5, 2)
+            max_features = st.number_input("Max features (0 = все)", 0, 200000, 0)
+            sublinear_tf = st.checkbox("TF-IDF sublinear_tf", value=True)
+            smooth_idf = st.checkbox("TF-IDF smooth_idf", value=True)
+
+        if st.button("🏁 Построить признаки", key="build_vectors"):
+            cfgs = []
+            for m in methods:
+                cfgs.append(VectorizationConfig(
+                    method=m,
+                    ngram_range=(int(n_min), int(n_max)),
+                    max_features=None if max_features == 0 else int(max_features),
+                    sublinear_tf=sublinear_tf,
+                    smooth_idf=smooth_idf,
+                ))
+            with st.spinner("Строим матрицы признаков..."):
+                vec_df, matrices = compare_vectorizers(texts, cfgs)
+                st.session_state["vec_df"] = vec_df
+                st.session_state["vec_matrices"] = matrices
+                try:
+                    os.makedirs("results", exist_ok=True)
+                    vec_path = "results/vectorization_metrics.csv"
+                    vec_df.to_csv(vec_path, index=False, encoding="utf-8")
+                    st.success(f"Метрики сохранены в {vec_path}")
+                except Exception as e:
+                    st.warning(f"Не удалось сохранить метрики: {e}")
+
+        if "vec_df" in st.session_state:
+            st.dataframe(st.session_state["vec_df"], use_container_width=True)
+            # Экспорт метрик
+            vec_csv = st.session_state["vec_df"].to_csv(index=False, encoding="utf-8")
+            st.download_button("📥 Скачать векторные метрики CSV", vec_csv, "vectorization_metrics.csv", "text/csv")
+
+            # LSA / снижение размерности
+            st.subheader("📉 LSA (TruncatedSVD) и проекции")
+            selected_key = st.selectbox("Выберите матрицу", list(st.session_state["vec_matrices"].keys()))
+            n_components = st.slider("Число компонент (SVD)", 2, 200, 100)
+            proj_method = st.radio("Метод проекции", ["umap", "tsne"], horizontal=True)
+            if st.button("🔎 Запустить LSA/проекции"):
+                X = st.session_state["vec_matrices"][selected_key]["X"]
+                vectorizer = st.session_state["vec_matrices"][selected_key]["vectorizer"]
+                feature_names = vectorizer.get_feature_names()
+                with st.spinner("Снижаем размерность..."):
+                    lsa = run_lsa(X, feature_names, SVDConfig(n_components=n_components))
+                    ev_table = explained_variance_table(lsa["explained_variance_ratio"]) 
+                    st.write("Объясненная дисперсия (первые 20):")
+                    st.dataframe(ev_table.head(20), use_container_width=True)
+                    st.write("Топ-термины по компонентам:")
+                    st.dataframe(top_terms_dataframe(lsa["top_terms_per_component"], top_k=10).head(50), use_container_width=True)
+                    # Проекция документов
+                    coords = embed_2d(lsa["X_reduced"], method=proj_method)
+                    proj_df = pd.DataFrame({"x": coords[:,0], "y": coords[:,1]})
+                    st.plotly_chart(px.scatter(proj_df, x="x", y="y", title=f"Проекция документов ({proj_method.upper()})"), use_container_width=True)
+
+    # ======== Эмбеддинги (ЛР2: Word2Vec/FastText/Doc2Vec + эксперименты) ========
+    with main_tabs[2]:
+        st.subheader("🧠 Обучение эмбеддингов и семантические эксперименты")
+        # Выбор корпуса для обучения и параметры
+        with st.expander("Параметры обучения", expanded=True):
+            corpus_choice = st.radio(
+                "Источник обучающих текстов",
+                ["Предобработанные", "Без предобработки"],
+                index=0, horizontal=True,
+                help="Предобработанные = применены ��астройки из блока Предобработка на левой панели"
             )
-        
-        with col2:
-            # JSON экспорт
-            json_data = results_df.to_json(orient='records', force_ascii=False, indent=2)
-            st.download_button(
-                label="📥 Скачать JSON",
-                data=json_data,
-                file_name="tokenization_results.json",
-                mime="application/json"
+            model_type = st.selectbox("Модель", ["w2v", "fasttext", "doc2vec"], 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)
+            epochs = st.slider("Эпохи", 1, 50, 10)
+            sg = st.radio("Архитектура (w2v/fasttext)", ["cbow", "skipgram"], index=1, horizontal=True)
+            dm = st.radio("Doc2Vec архитектура", ["pv-dm", "pv-dbow"], index=0, horizontal=True)
+
+        # Инфо о корпусе, предпросмотр и экспорт
+        meta = st.session_state.get("data_meta", {})
+        corpus = st.session_state.get("processed_texts", []) if corpus_choice == "Предобработанные" else st.session_state.get("raw_texts", [])
+        st.info(f"Источник данных: {meta.get('source','неизвестно')} | Текстов: {len(corpus)}")
+        if corpus:
+            with st.expander("Просмотр обучающего корпуса (первые 3 текста)", expanded=False):
+                st.write(corpus[:3])
+            # Скачать текущий обучающий корпус
+            corpus_txt = ("\n".join(corpus)).encode("utf-8")
+            st.download_button("📥 Скачать обучающий корпус (.txt)", data=corpus_txt, file_name="training_corpus.txt", mime="text/plain")
+
+        if st.button("🎓 Обучить модель", key="train_embeddings"):
+            cfg = EmbTrainConfig(
+                model_type=model_type,
+                vector_size=int(vector_size),
+                window=int(window),
+                min_count=int(min_count),
+                epochs=int(epochs),
+                sg=1 if sg == "skipgram" else 0,
+                dm=1 if dm == "pv-dm" else 0,
             )
-    
-    # Информация о проекте
-    st.sidebar.markdown("---")
-    st.sidebar.subheader("ℹ️ О проекте")
-    st.sidebar.info("""
-    **Лабораторная работа №1**
-    
-    Сравнительный анализ методов токенизации и нормализации текста на материале русскоязычных новостных корпусов.
-    
-    **Возможности:**
-    - Сравнение различных методов токенизации
-    - Предобработка и очистка текста
-    - Визуализация результатов
-    - Экспорт данных
-    """)
+            with st.spinner("Обучаем модель..."):
+                model, tt = train_embeddings_model(corpus, cfg)
+                st.session_state["emb_model"] = model
+                st.session_state["emb_train_time"] = tt
+                st.success(f"Модель обучена за {tt:.2f} с")
+
+        if "emb_model" in st.session_state:
+            model = st.session_state["emb_model"]
+            col1, col2 = st.columns(2)
+            with col1:
+                save_name = st.text_input("Имя файла модели", "models/russian_news_embeddings.model")
+                if st.button("💾 Сохранить модель"):
+                    save_embedding_model(model, save_name)
+                    st.success(f"Сохранено: {save_name}")
+            with col2:
+                test_word = st.text_input("Проверить ближайших соседей для слова", "россия")
+                if st.button("🔍 Найти соседей"):
+                    res = nearest_neighbors(model, [test_word], topn=10)
+                    st.write(res.get(test_word, []))
+
+            st.markdown("---")
+            st.subheader("🧪 Семантические операции")
+            col1, col2 = st.columns(2)
+            with col1:
+                expr = st.text_input("Векторная арифметика", "король - мужчина + женщина")
+                if st.button("➡️ Посчитать", key="arith"):
+                    st.write(vector_arithmetic(model, expr, topn=10))
+            with col2:
+                a = st.text_input("Ось: A", "мужчина")
+                b = st.text_input("Ось: B", "женщина")
+                words = st.text_area("Слова для проекции (через запятую)", "король, королева, доктор, медсестра")
+                if st.button("📏 Проекц��я на ось"):
+                    wlist = [w.strip() for w in words.split(",") if w.strip()]
+                    st.dataframe(semantic_axis(model, a, b, wlist), use_container_width=True)
+
+            st.markdown("---")
+            st.subheader("📐 Косинусное сходство и аналогии")
+            col1, col2 = st.columns(2)
+            with col1:
+                pair_a = st.text_input("Пара A", "москва")
+                pair_b = st.text_input("Пара B", "россия")
+                if st.button("🔗 Косинус", key="cos"):
+                    st.write(eval_cosine(model, [(pair_a, pair_b)]))
+            with col2:
+                ana_a = st.text_input("Аналогия: A", "мужчина")
+                ana_b = st.text_input("Аналогия: B", "женщина")
+                ana_c = st.text_input("Аналогия: C", "король")
+                if st.button("🧩 Аналогия"):
+                    st.write(eval_analogy(model, ana_a, ana_b, ana_c, topn=10))
 
 
 if __name__ == "__main__":

src/tokenizers_cmp.py

@@ -128,7 +128,16 @@ class TokenizationComparator:
     
     def _tokenize_nltk(self, text: str) -> List[str]:
         """Токенизация с помощью NLTK."""
-        return word_tokenize(text, language='russian')
+        try:
+            return word_tokenize(text, language='russian')
+        except LookupError:
+            # Автоматическая загрузка необходимых данных NLTK (punkt)
+            import nltk  # local import to avoid hard dependency if NLTK not used
+            try:
+                nltk.download('punkt', quiet=True)
+            except Exception:
+                pass
+            return word_tokenize(text, language='russian')
     
     def _tokenize_spacy(self, text: str) -> List[str]:
         """Токенизация с помощью SpaCy."""

src/universal_preprocessor.py

@@ -108,9 +108,11 @@ PUNCTUATION_MAP = {
     '«': '"',
     '»': '"',
     '„': '"',
+    '“': '"',
+    '”': '"',
     '"': '"',
-    ''': "'",
-    ''': "'",
+    '‘': "'",
+    '’': "'",
     '`': "'",
     '´': "'",
 }

src/utils.py

@@ -1,452 +1,80 @@
 # src/utils.py
 """
-Вспомогательные функции для проекта анализа токенизации.
-Содержит утилиты для работы с файлами, метриками и визуализацией.
+Вспомогательные утилиты: загрузка JSONL, вычисление статистики по текстам,
+создание сводной информации о корпусе и сохранение результатов.
 """
 
-import os
+from __future__ import annotations
+
 import json
-import time
-from typing import List, Dict, Any, Optional, Tuple
-from pathlib import Path
-import pandas as pd
-import numpy as np
 from collections import Counter
-import matplotlib.pyplot as plt
-import seaborn as sns
-
-
-def ensure_directory(path: str) -> Path:
-    """
-    Создает директорию, если она не существует.
-    
-    Args:
-        path: Путь к директории
-    
-    Returns:
-        Path объект директории
-    """
-    dir_path = Path(path)
-    dir_path.mkdir(parents=True, exist_ok=True)
-    return dir_path
-
-
-def save_json(data: Any, file_path: str, ensure_ascii: bool = False) -> None:
-    """
-    Сохраняет данные в JSON файл.
-    
-    Args:
-        data: Данные для сохранения
-        file_path: Путь к файлу
-        ensure_ascii: Использовать ASCII кодировку
-    """
-    ensure_directory(os.path.dirname(file_path))
-    
-    with open(file_path, 'w', encoding='utf-8') as f:
-        json.dump(data, f, ensure_ascii=ensure_ascii, indent=2)
-
-
-def load_json(file_path: str) -> Any:
-    """
-    Загружает данные из JSON файла.
-    
-    Args:
-        file_path: Путь к файлу
-    
-    Returns:
-        Загруженные данные
-    """
-    with open(file_path, 'r', encoding='utf-8') as f:
-        return json.load(f)
-
+from dataclasses import dataclass, asdict
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Tuple, Optional
 
-def save_jsonl(data: List[Dict], file_path: str) -> None:
-    """
-    Сохраняет список словарей в JSONL файл.
-    
-    Args:
-        data: Список словарей
-        file_path: Путь к файлу
-    """
-    ensure_directory(os.path.dirname(file_path))
-    
-    with open(file_path, 'w', encoding='utf-8') as f:
-        for item in data:
-            f.write(json.dumps(item, ensure_ascii=False) + '\n')
+import numpy as np
 
 
-def load_jsonl(file_path: str, max_items: Optional[int] = None) -> List[Dict]:
-    """
-    Загружает данные из JSONL файла.
-    
-    Args:
-        file_path: Путь к файлу
-        max_items: Максимальное количество элементов для загрузки
-    
-    Returns:
-        Список словарей
-    """
-    data = []
-    with open(file_path, 'r', encoding='utf-8') as f:
+def load_jsonl(path: str, max_items: Optional[int] = None) -> List[Dict[str, Any]]:
+    items: List[Dict[str, Any]] = []
+    with open(path, "r", encoding="utf-8") as f:
         for i, line in enumerate(f):
-            if max_items and i >= max_items:
+            if max_items is not None and i >= max_items:
                 break
-            
             line = line.strip()
-            if line:
-                try:
-                    data.append(json.loads(line))
-                except json.JSONDecodeError:
-                    continue
-    
-    return data
-
-
-def calculate_text_statistics(texts: List[str]) -> Dict[str, Any]:
-    """
-    Вычисляет статистику для списка текстов.
-    
-    Args:
-        texts: Список текстов
-    
-    Returns:
-        Словарь со статистикой
-    """
-    if not texts:
-        return {}
-    
-    # Общая статистика
-    total_texts = len(texts)
-    total_chars = sum(len(text) for text in texts)
-    total_words = sum(len(text.split()) for text in texts)
-    
-    # Статистика по длинам
-    text_lengths = [len(text) for text in texts]
-    word_counts = [len(text.split()) for text in texts]
-    
-    # Статистика по символам
-    char_counts = Counter()
-    for text in texts:
-        char_counts.update(text.lower())
-    
-    # Статистика по словам
-    word_counts_counter = Counter()
-    for text in texts:
-        words = text.lower().split()
-        word_counts_counter.update(words)
-    
+            if not line:
+                continue
+            try:
+                items.append(json.loads(line))
+            except json.JSONDecodeError:
+                continue
+    return items
+
+
+def calculate_text_statistics(texts: Iterable[str], top_k: int = 50) -> Dict[str, Any]:
+    texts_list = [t for t in texts if isinstance(t, str) and t.strip()]
+    total_texts = len(texts_list)
+    words: List[str] = []
+    for t in texts_list:
+        words.extend(t.split())
+    total_words = len(words)
+    unique_words = len(set(words))
+    avg_words_per_text = (total_words / total_texts) if total_texts else 0.0
+    freq = Counter(words)
+    most_common_words = freq.most_common(top_k)
     return {
-        'total_texts': total_texts,
-        'total_characters': total_chars,
-        'total_words': total_words,
-        'avg_text_length': np.mean(text_lengths),
-        'median_text_length': np.median(text_lengths),
-        'avg_words_per_text': np.mean(word_counts),
-        'median_words_per_text': np.median(word_counts),
-        'unique_characters': len(char_counts),
-        'unique_words': len(word_counts_counter),
-        'most_common_chars': char_counts.most_common(10),
-        'most_common_words': word_counts_counter.most_common(10),
-        'text_length_stats': {
-            'min': min(text_lengths),
-            'max': max(text_lengths),
-            'std': np.std(text_lengths)
-        },
-        'word_count_stats': {
-            'min': min(word_counts),
-            'max': max(word_counts),
-            'std': np.std(word_counts)
-        }
+        "total_texts": total_texts,
+        "total_words": total_words,
+        "unique_words": unique_words,
+        "avg_words_per_text": avg_words_per_text,
+        "most_common_words": most_common_words,
     }
 
 
-def create_word_frequency_plot(word_counts: Counter, top_n: int = 20, 
-                             title: str = "Частотность слов") -> plt.Figure:
-    """
-    Создает график частотности слов.
-    
-    Args:
-        word_counts: Счетчик слов
-        top_n: Количество топ слов для отображения
-        title: Заголовок графика
-    
-    Returns:
-        Объект matplotlib Figure
-    """
-    most_common = word_counts.most_common(top_n)
-    words, counts = zip(*most_common)
-    
-    fig, ax = plt.subplots(figsize=(12, 8))
-    bars = ax.barh(range(len(words)), counts)
-    ax.set_yticks(range(len(words)))
-    ax.set_yticklabels(words)
-    ax.set_xlabel('Частота')
-    ax.set_title(title)
-    ax.invert_yaxis()
-    
-    # Добавляем значения на столбцы
-    for i, bar in enumerate(bars):
-        width = bar.get_width()
-        ax.text(width + 0.1, bar.get_y() + bar.get_height()/2, 
-                f'{int(width)}', ha='left', va='center')
-    
-    plt.tight_layout()
-    return fig
-
-
-def create_length_distribution_plot(lengths: List[int], title: str = "Распределение длин") -> plt.Figure:
-    """
-    Создает график распределения длин.
-    
-    Args:
-        lengths: Список длин
-        title: Заголовок графика
-    
-    Returns:
-        Объект matplotlib Figure
-    """
-    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))
-    
-    # Гистограмма
-    ax1.hist(lengths, bins=30, alpha=0.7, color='skyblue', edgecolor='black')
-    ax1.set_xlabel('Длина')
-    ax1.set_ylabel('Частота')
-    ax1.set_title(f'{title} - Гистограмма')
-    ax1.grid(True, alpha=0.3)
-    
-    # Box plot
-    ax2.boxplot(lengths, vert=True)
-    ax2.set_ylabel('Длина')
-    ax2.set_title(f'{title} - Box Plot')
-    ax2.grid(True, alpha=0.3)
-    
-    plt.tight_layout()
-    return fig
-
-
-def create_tokenization_comparison_plot(results_df: pd.DataFrame) -> plt.Figure:
-    """
-    Создает сравнительный график методов токенизации.
-    
-    Args:
-        results_df: DataFrame с результатами сравнения
-    
-    Returns:
-        Объект matplotlib Figure
-    """
-    fig, axes = plt.subplots(2, 2, figsize=(15, 12))
-    
-    # Время обработки
-    axes[0, 0].bar(results_df['Метод'], results_df['Время обработки (сек)'])
-    axes[0, 0].set_title('Время обработки')
-    axes[0, 0].set_ylabel('Секунды')
-    axes[0, 0].tick_params(axis='x', rotation=45)
-    
-    # Размер словаря
-    axes[0, 1].bar(results_df['Метод'], results_df['Размер словаря'])
-    axes[0, 1].set_title('Размер словаря')
-    axes[0, 1].set_ylabel('Количество токенов')
-    axes[0, 1].tick_params(axis='x', rotation=45)
-    
-    # Коэффициент сжатия
-    axes[1, 0].bar(results_df['Метод'], results_df['Коэффициент сжатия'])
-    axes[1, 0].set_title('Коэффициент сжатия')
-    axes[1, 0].set_ylabel('Отношение')
-    axes[1, 0].tick_params(axis='x', rotation=45)
-    
-    # Средняя длина токена
-    axes[1, 1].bar(results_df['Метод'], results_df['Средняя длина токена'])
-    axes[1, 1].set_title('Средняя длина токена')
-    axes[1, 1].set_ylabel('Символы')
-    axes[1, 1].tick_params(axis='x', rotation=45)
-    
-    plt.tight_layout()
-    return fig
-
-
-def calculate_oov_rate(tokens: List[str], vocabulary: set) -> float:
-    """
-    Вычисляет процент OOV (Out-of-Vocabulary) токенов.
-    
-    Args:
-        tokens: Список токенов
-        vocabulary: Словарь (множество известных токенов)
-    
-    Returns:
-        Процент OOV токенов
-    """
-    if not tokens:
-        return 0.0
-    
-    oov_count = sum(1 for token in tokens if token not in vocabulary)
-    return oov_count / len(tokens)
-
-
-def calculate_fragmentation_rate(original_words: List[str], tokens: List[str]) -> float:
-    """
-    Вычисляет процент фрагментации слов.
-    
-    Args:
-        original_words: Исходные слова
-        tokens: Токены после обработки
-    
-    Returns:
-        Процент фрагментированных слов
-    """
-    if not original_words:
-        return 0.0
-    
-    fragmented_count = 0
-    token_idx = 0
-    
-    for word in original_words:
-        word_tokens = []
-        word_length = len(word.split())
-        
-        # Собираем токены для текущего слова
-        for _ in range(word_length):
-            if token_idx < len(tokens):
-                word_tokens.append(tokens[token_idx])
-                token_idx += 1
-        
-        # Если слово разбито на несколько токенов
-        if len(word_tokens) > 1:
-            fragmented_count += 1
-    
-    return fragmented_count / len(original_words)
-
-
-def create_corpus_summary(corpus_path: str, output_path: str) -> Dict[str, Any]:
-    """
-    Создает сводку по корпусу и сохраняет в файл.
-    
-    Args:
-        corpus_path: Путь к корпусу
-        output_path: Путь для сохранения сводки
-    
-    Returns:
-        Словарь со сводкой
-    """
-    # Загружаем корпус
-    articles = load_jsonl(corpus_path)
-    texts = [article.get('text', '') for article in articles if article.get('text')]
-    
-    # Вычисляем статистику
-    stats = calculate_text_statistics(texts)
-    
-    # Добавляем информацию о корпусе
-    summary = {
-        'corpus_info': {
-            'path': corpus_path,
-            'total_articles': len(articles),
-            'articles_with_text': len(texts),
-            'created_at': time.strftime('%Y-%m-%d %H:%M:%S')
-        },
-        'statistics': stats
-    }
-    
-    # Сохраняем сводку
-    save_json(summary, output_path)
-    
-    return summary
-
-
-def format_time(seconds: float) -> str:
-    """
-    Форматирует время в читаемый вид.
-    
-    Args:
-        seconds: Время в секундах
-    
-    Returns:
-        Отформатированная строка времени
-    """
-    if seconds < 60:
-        return f"{seconds:.2f} сек"
-    elif seconds < 3600:
-        minutes = seconds / 60
-        return f"{minutes:.2f} мин"
-    else:
-        hours = seconds / 3600
-        return f"{hours:.2f} ч"
-
-
-def print_progress_bar(iteration: int, total: int, prefix: str = '', 
-                      suffix: str = '', length: int = 50) -> None:
-    """
-    Выводит прогресс-бар в консоль.
-    
-    Args:
-        iteration: Текущая итерация
-        total: Общее количество итераций
-        prefix: Префикс для прогресс-бара
-        suffix: Суффикс для прогресс-бара
-        length: Длина прогресс-бара
-    """
-    percent = ("{0:.1f}").format(100 * (iteration / float(total)))
-    filled_length = int(length * iteration // total)
-    bar = '█' * filled_length + '-' * (length - filled_length)
-    print(f'\r{prefix} |{bar}| {percent}% {suffix}', end='\r')
-    
-    if iteration == total:
-        print()
-
-
-def validate_corpus_format(file_path: str) -> Tuple[bool, str]:
-    """
-    Проверяет формат корпуса.
-    
-    Args:
-        file_path: Путь к файлу корпуса
-    
-    Returns:
-        Кортеж (валидность, сообщение об ошибке)
-    """
-    try:
-        articles = load_jsonl(file_path, max_items=10)
-        
-        if not articles:
-            return False, "Файл пуст или не содержит валидных JSON объектов"
-        
-        # Проверяем структуру первого объекта
-        first_article = articles[0]
-        required_fields = ['text']
-        
-        for field in required_fields:
-            if field not in first_article:
-                return False, f"Отсутствует обязательное поле: {field}"
-        
-        if not isinstance(first_article['text'], str):
-            return False, "Поле 'text' должно быть строкой"
-        
-        if not first_article['text'].strip():
-            return False, "Поле 'text' не может быть пустым"
-        
-        return True, "Корпус валиден"
-        
-    except Exception as e:
-        return False, f"Ошибка при проверке корпуса: {e}"
-
-
-if __name__ == "__main__":
-    # Пример использования
-    print("Утилиты для анализа токенизации")
-    
-    # Тестовые данные
-    test_texts = [
-        "Это тестовый текст для проверки функций.",
-        "Второй текст содержит больше слов для анализа.",
-        "Третий текст завершает набор тестовых данных."
-    ]
-    
-    # Вычисляем статистику
-    stats = calculate_text_statistics(test_texts)
-    print(f"Статистика текстов: {stats['total_texts']} текстов, {stats['total_words']} слов")
-    
-    # Проверяем формат корпуса
-    corpus_path = "data/raw_corpus.jsonl"
-    if os.path.exists(corpus_path):
-        is_valid, message = validate_corpus_format(corpus_path)
-        print(f"Корпус валиден: {is_valid}, сообщение: {message}")
-    else:
-        print("Корпус не найден")
+@dataclass
+class CorpusSummary:
+    total_articles: int
+    total_words: int
+    avg_words_per_article: float
+    unique_words: int
+    categories: Dict[str, int]
+
+
+def create_corpus_summary(articles: List[Dict[str, Any]]) -> CorpusSummary:
+    texts = [a.get("text", "") for a in articles if isinstance(a, dict)]
+    cats = [a.get("category", "") or "" for a in articles if isinstance(a, dict)]
+    stats = calculate_text_statistics(texts, top_k=0)
+    categories_counter = Counter([c for c in cats if isinstance(c, str) and c.strip()])
+    return CorpusSummary(
+        total_articles=len(texts),
+        total_words=stats["total_words"],
+        avg_words_per_article=float(stats["avg_words_per_text"]),
+        unique_words=stats["unique_words"],
+        categories=dict(categories_counter),
+    )
+
+
+def save_corpus_summary(summary: CorpusSummary, out_path: str = "results/corpus_summary.json") -> None:
+    Path(Path(out_path).parent).mkdir(parents=True, exist_ok=True)
+    with open(out_path, "w", encoding="utf-8") as f:
+        json.dump(asdict(summary), f, ensure_ascii=False, indent=2)