Initial clean commit for HF Space (models via Git LFS)

.dockerignore

@@ -0,0 +1,27 @@
+@'
+# Python / venv / байт-код
+.venv
+__pycache__/
+*.py[cod]
+*.egg-info/
+
+# НЕ класть в build context — большие локальные папки и кэши
+hf_cache/
+**/hf_cache/**
+.cache/
+**/.cache/**
+data/
+models/
+models_all/
+reports/
+catboost_info/
+predicted.csv
+
+# VCS/IDE мусор
+.git
+.gitignore
+.idea
+.ipynb_checkpoints
+tests/.pytest_cache
+.pytest_cache
+'@ | Set-Content -Encoding utf8 .dockerignore

.env

@@ -0,0 +1 @@
+HF_HUB_DISABLE_SYMLINKS_WARNING=1

.gitattributes

@@ -0,0 +1,7 @@
+*.cbm filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.csv filter=lfs diff=lfs merge=lfs -text
+*.xlsx filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tsv filter=lfs diff=lfs merge=lfs -text
+structure.txt filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,27 @@
+# виртуальные окружения / IDE
+.venv/
+venv/
+.idea/
+.vscode/
+
+# кэш/сервисы
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.pytest_cache/
+.ipynb_checkpoints/
+.cache/
+*.log
+
+# локальные данные/выводы
+data/
+out/
+*.csv
+*.xlsx
+*.tsv
+*.png
+*.pdf
+
+# большие/неиспользуемые модели
+models_all/

.streamlit/config.toml

@@ -0,0 +1,6 @@
+[server]
+headless = true
+maxUploadSize = 200
+
+[browser]
+gatherUsageStats = false

Dockerfile

@@ -0,0 +1,12 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 8000
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Dockerfile-ui

@@ -0,0 +1,23 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# Копируем requirements
+COPY ui/requirements.txt .
+
+# Устанавливаем зависимости
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Копируем код приложения
+COPY ui/app.py .
+
+# Создаем папку для шаблонов (если нужна)
+RUN mkdir -p templates
+
+# Копируем шаблоны (если есть)
+COPY ui/templates/ ./templates/
+
+EXPOSE 8080
+
+# Запускаем приложение
+CMD ["python", "-m", "uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8080"]

Makefile

@@ -0,0 +1,16 @@
+.PHONY: train predict api ui test docker
+
+predict:
+	python -m src.predict --input data/raw/Данные\ для\ кейса.csv --output data/processed/predicted.csv
+
+api:
+	uvicorn app.main:app --host 127.0.0.1 --port 8020 --reload
+
+ui:
+	streamlit run app/ui.py
+
+test:
+	pytest -q
+
+docker:
+	docker compose up --build

README.md

@@ -0,0 +1,15 @@
+# 🧠 Автооценка устных ответов (RFL • CatBoost + ruSBERT)
+
+### 📌 Описание
+Проект предназначен для автоматической оценки устных ответов на экзаменах по русскому языку как иностранному (RFL).  
+Используются модели **CatBoost Q1–Q4** и признаки из **ruSBERT** (эмбеддинги).
+
+---
+
+### 🚀 Быстрый старт
+
+#### 1️⃣ Локальный запуск
+
+```bash
+pip install -r requirements.txt
+python src/predict.py -i "data/raw/Данные для кейса.csv" -o "out/predicted.csv"

analyze_features.py

@@ -0,0 +1,124 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+
+def analyze_extracted_features():
+    """Анализ извлеченных признаков"""
+
+    # Загружаем извлеченные признаки
+    features_df = pd.read_csv('real_data_features.csv', index_col=0)
+
+    print("📊 ДЕТАЛЬНЫЙ АНАЛИЗ ИЗВЛЕЧЕННЫХ ПРИЗНАКОВ")
+    print("=" * 50)
+
+    print(f"Всего признаков: {len(features_df.columns)}")
+    print(f"Обработано строк: {len(features_df)}")
+
+    # Анализ заполненности
+    null_analysis = features_df.isnull().sum()
+    null_features = null_analysis[null_analysis > 0]
+
+    if len(null_features) > 0:
+        print(f"\n❌ Признаки с пропусками:")
+        for feature, null_count in null_features.items():
+            print(f"   {feature}: {null_count} пропусков ({null_count / len(features_df):.1%})")
+    else:
+        print(f"\n✅ Все признаки полностью заполнены!")
+
+    # Статистика по числовым признакам
+    numeric_features = features_df.select_dtypes(include=[np.number])
+
+    print(f"\n📈 СТАТИСТИКА ПРИЗНАКОВ:")
+    stats_summary = numeric_features.agg(['mean', 'std', 'min', 'max']).T
+    stats_summary['cv'] = stats_summary['std'] / stats_summary['mean']  # Коэффициент вариации
+
+    # Показываем топ-10 самых информативных признаков
+    informative_features = stats_summary[stats_summary['std'] > 0].sort_values('cv', ascending=False)
+
+    print(f"\n🎯 ТОП-10 самых информативных признаков (по вариативности):")
+    for feature, row in informative_features.head(10).iterrows():
+        print(f"   {feature:25} mean={row['mean']:6.2f} std={row['std']:6.2f} cv={row['cv']:.2f}")
+
+    # Визуализация распределения ключевых признаков
+    key_features = ['text_length', 'word_count', 'lexical_diversity', 'composite_quality_score']
+    available_features = [f for f in key_features if f in numeric_features.columns]
+
+    if available_features:
+        plt.figure(figsize=(15, 10))
+
+        for i, feature in enumerate(available_features, 1):
+            plt.subplot(2, 2, i)
+            plt.hist(numeric_features[feature].dropna(), bins=20, alpha=0.7, edgecolor='black')
+            plt.title(f'Распределение {feature}')
+            plt.xlabel(feature)
+            plt.ylabel('Частота')
+
+        plt.tight_layout()
+        plt.savefig('features_distribution.png', dpi=150, bbox_inches='tight')
+        plt.show()
+        print(f"\n📊 Визуализация сохранена в features_distribution.png")
+
+    # Анализ корреляций между признаками
+    if len(numeric_features.columns) > 5:
+        # Выбираем топ-15 самых вариативных признаков для корреляционной матрицы
+        top_features = informative_features.head(15).index.tolist()
+
+        plt.figure(figsize=(12, 10))
+        correlation_matrix = numeric_features[top_features].corr()
+
+        mask = np.triu(np.ones_like(correlation_matrix, dtype=bool))
+        sns.heatmap(correlation_matrix, mask=mask, annot=True, fmt='.2f', cmap='coolwarm',
+                    center=0, square=True, cbar_kws={"shrink": .8})
+        plt.title('Корреляционная матрица признаков (топ-15)')
+        plt.tight_layout()
+        plt.savefig('features_correlation.png', dpi=150, bbox_inches='tight')
+        plt.show()
+        print(f"📈 Корреляционная матрица сохранена в features_correlation.png")
+
+    # Анализ качества композитного показателя
+    if 'composite_quality_score' in numeric_features.columns:
+        print(f"\n🎯 АНАЛИЗ КОМПОЗИТНОГО ПОКАЗАТЕЛЯ КАЧЕСТВА:")
+        quality_scores = numeric_features['composite_quality_score']
+        print(f"   Среднее: {quality_scores.mean():.3f}")
+        print(f"   Стандартное отклонение: {quality_scores.std():.3f}")
+        print(f"   Диапазон: [{quality_scores.min():.3f}, {quality_scores.max():.3f}]")
+
+        # Распределение по квантилям
+        quantiles = quality_scores.quantile([0.25, 0.5, 0.75])
+        print(f"   Квантили: 25%={quantiles[0.25]:.3f}, 50%={quantiles[0.5]:.3f}, 75%={quantiles[0.75]:.3f}")
+
+
+def check_feature_correlations_with_target():
+    """Проверка корреляции признаков с целевой переменной (если есть оценки)"""
+
+    features_df = pd.read_csv('real_data_features.csv', index_col=0)
+
+    # Ищем колонку с оценками в исходных данных
+    score_columns = [col for col in features_df.columns if 'score' in col.lower() or 'оценк' in col.lower()]
+
+    if score_columns:
+        target_col = score_columns[0]
+        print(f"\n🎯 КОРРЕЛЯЦИЯ ПРИЗНАКОВ С {target_col}:")
+        print("-" * 40)
+
+        correlations = features_df.corr()[target_col].abs().sort_values(ascending=False)
+
+        # Показываем топ-10 наиболее коррелирующих признаков
+        top_correlated = correlations.head(11)  # +1 потому что target сам с собой
+
+        for feature, corr in top_correlated.items():
+            if feature != target_col:
+                actual_corr = features_df.corr()[target_col][feature]
+                direction = "↑" if actual_corr > 0 else "↓"
+                significance = "***" if abs(actual_corr) > 0.3 else "**" if abs(actual_corr) > 0.2 else "*" if abs(
+                    actual_corr) > 0.1 else ""
+                print(f"   {direction} {feature:25} {actual_corr:+.3f} {significance}")
+    else:
+        print(f"\nℹ️ Целевая переменная (оценки) не найдена в данных")
+
+
+if __name__ == "__main__":
+    analyze_extracted_features()
+    check_feature_correlations_with_target()

analyze_features_simple.py

@@ -0,0 +1,169 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+def analyze_extracted_features():
+    """Анализ извлеченных признаков без сложных зависимостей"""
+
+    try:
+        # Загружаем извлеченные признаки
+        features_df = pd.read_csv('real_data_features.csv', index_col=0)
+    except FileNotFoundError:
+        print("❌ Файл real_data_features.csv не найден!")
+        print("💡 Сначала запустите test_real_data.py")
+        return
+
+    print("📊 ДЕТАЛЬНЫЙ АНАЛИЗ ИЗВЛЕЧЕННЫХ ПРИЗНАКОВ")
+    print("=" * 50)
+
+    print(f"Всего признаков: {len(features_df.columns)}")
+    print(f"Обработано строк: {len(features_df)}")
+
+    # Анализ заполненности
+    null_analysis = features_df.isnull().sum()
+    null_features = null_analysis[null_analysis > 0]
+
+    if len(null_features) > 0:
+        print(f"\n❌ Признаки с пропусками:")
+        for feature, null_count in null_features.items():
+            print(f"   {feature}: {null_count} пропусков ({null_count / len(features_df):.1%})")
+    else:
+        print(f"\n✅ Все признаки полностью заполнены!")
+
+    # Статистика по числовым признакам
+    numeric_features = features_df.select_dtypes(include=[np.number])
+
+    print(f"\n📈 СТАТИСТИКА ПРИЗНАКОВ:")
+    stats_summary = numeric_features.agg(['mean', 'std', 'min', 'max']).T
+    stats_summary['cv'] = stats_summary['std'] / stats_summary['mean']  # Коэффициент вариации
+
+    # Показываем топ-10 самых информативных признаков
+    informative_features = stats_summary[stats_summary['std'] > 0].sort_values('cv', ascending=False)
+
+    print(f"\n🎯 ТОП-15 самых информативных признаков (по вариативности):")
+    for feature, row in informative_features.head(15).iterrows():
+        print(f"   {feature:25} mean={row['mean']:6.2f} std={row['std']:6.2f} cv={row['cv']:.2f}")
+
+    # Визуализация распределения ключевых признаков
+    key_features = ['text_length', 'word_count', 'lexical_diversity', 'composite_quality_score']
+    available_features = [f for f in key_features if f in numeric_features.columns]
+
+    if available_features:
+        plt.figure(figsize=(15, 10))
+
+        for i, feature in enumerate(available_features, 1):
+            plt.subplot(2, 2, i)
+            plt.hist(numeric_features[feature].dropna(), bins=20, alpha=0.7, edgecolor='black')
+            plt.title(f'Распределение {feature}')
+            plt.xlabel(feature)
+            plt.ylabel('Частота')
+
+        plt.tight_layout()
+        plt.savefig('features_distribution.png', dpi=150, bbox_inches='tight')
+        plt.show()
+        print(f"\n📊 Визуализация сохранена в features_distribution.png")
+
+    # Анализ качества композитного показателя
+    if 'composite_quality_score' in numeric_features.columns:
+        print(f"\n🎯 АНАЛИЗ КОМПОЗИТНОГО ПОКАЗАТЕЛЯ КАЧЕСТВА:")
+        quality_scores = numeric_features['composite_quality_score']
+        print(f"   Среднее: {quality_scores.mean():.3f}")
+        print(f"   Стандартное отклонение: {quality_scores.std():.3f}")
+        print(f"   Диапазон: [{quality_scores.min():.3f}, {quality_scores.max():.3f}]")
+
+        # Распределение по квантилям
+        quantiles = quality_scores.quantile([0.25, 0.5, 0.75])
+        print(f"   Квантили: 25%={quantiles[0.25]:.3f}, 50%={quantiles[0.5]:.3f}, 75%={quantiles[0.75]:.3f}")
+
+        # Анализ что влияет на качество
+        print(f"\n🔍 КОРРЕЛЯЦИЯ С КОМПОЗИТНЫМ ПОКАЗАТЕЛЕМ:")
+        correlations = numeric_features.corr()['composite_quality_score'].abs().sort_values(ascending=False)
+
+        for feature, corr in correlations.head(10).items():
+            if feature != 'composite_quality_score':
+                actual_corr = numeric_features.corr()['composite_quality_score'][feature]
+                direction = "↑" if actual_corr > 0 else "↓"
+                print(f"   {direction} {feature:25} {actual_corr:+.3f}")
+
+
+def check_feature_correlations_with_target():
+    """Проверка корреляции признаков с целевой переменной (если есть оценки)"""
+
+    try:
+        features_df = pd.read_csv('real_data_features.csv', index_col=0)
+    except FileNotFoundError:
+        return
+
+    # Ищем колонку с оценками в исходных данных
+    score_columns = [col for col in features_df.columns if
+                     'score' in col.lower() or 'оценк' in col.lower() or 'балл' in col.lower()]
+
+    if score_columns:
+        target_col = score_columns[0]
+        print(f"\n🎯 КОРРЕЛЯЦИЯ ПРИЗНАКОВ С {target_col}:")
+        print("-" * 50)
+
+        correlations = features_df.corr()[target_col].abs().sort_values(ascending=False)
+
+        # Показываем топ-10 наиболее коррелирующих признаков
+        top_correlated = correlations.head(11)  # +1 потому что target сам с собой
+
+        print(f"   {'ПРИЗНАК':<25} {'КОРРЕЛЯЦИЯ':<10} {'ЗНАЧИМОСТЬ'}")
+        print(f"   {'-' * 25} {'-' * 10} {'-' * 10}")
+
+        for feature, corr in top_correlated.items():
+            if feature != target_col:
+                actual_corr = features_df.corr()[target_col][feature]
+                direction = "↑" if actual_corr > 0 else "↓"
+                significance = "***" if abs(actual_corr) > 0.3 else "**" if abs(actual_corr) > 0.2 else "*" if abs(
+                    actual_corr) > 0.1 else ""
+                print(f"   {direction} {feature:<23} {actual_corr:+.3f}    {significance}")
+    else:
+        print(f"\nℹ️ Целевая переменная (оценки) не найдена в данных")
+
+
+def analyze_feature_categories():
+    """Анализ признаков по категориям"""
+
+    try:
+        features_df = pd.read_csv('real_data_features.csv', index_col=0)
+    except FileNotFoundError:
+        return
+
+    # Группируем признаки по категориям
+    categories = {
+        '📝 ТЕКСТОВЫЕ': ['text_length', 'word_count', 'sentence_count', 'avg_sentence_length',
+                        'avg_word_length', 'lexical_diversity', 'long_word_ratio', 'text_complexity'],
+        '🎯 СЕМАНТИЧЕСКИЕ': ['semantic_similarity', 'keyword_overlap', 'tfidf_similarity', 'response_relevance'],
+        '📚 ГРАММАТИЧЕСКИЕ': ['grammar_error_count', 'grammar_error_ratio', 'has_punctuation',
+                             'sentence_completeness', 'proper_capitalization'],
+        '💬 ДИСКУРС': ['has_greeting', 'has_questions', 'has_description', 'has_connectors',
+                      'has_emotional_words', 'coherence_score'],
+        '❓ ТИПЫ ВОПРОСОВ': ['dialog_initiation', 'response_adequacy', 'information_seeking',
+                            'descriptive_detail', 'answer_length_sufficiency', 'question_type'],
+        '⭐ КАЧЕСТВО': ['composite_quality_score', 'social_appropriateness', 'interaction_quality']
+    }
+
+    print(f"\n📂 РАСПРЕДЕЛЕНИЕ ПРИЗНАКОВ ПО КАТЕГОРИЯМ:")
+    print("=" * 50)
+
+    numeric_features = features_df.select_dtypes(include=[np.number])
+
+    for category, features in categories.items():
+        available_features = [f for f in features if f in numeric_features.columns]
+        if available_features:
+            print(f"\n{category} ({len(available_features)} признаков):")
+            for feature in available_features:
+                mean_val = numeric_features[feature].mean()
+                std_val = numeric_features[feature].std()
+                print(f"   • {feature:25} {mean_val:6.3f} ± {std_val:5.3f}")
+
+
+if __name__ == "__main__":
+    analyze_extracted_features()
+    check_feature_correlations_with_target()
+    analyze_feature_categories()
+
+    print(f"\n✅ Анализ завершен!")
+    print("💡 Рекомендации будут основаны на этом анализе")

analyze_results.py

@@ -0,0 +1,439 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+from collections import Counter
+import numpy as np
+import os
+import warnings
+
+warnings.filterwarnings('ignore')
+
+# Настройка отображения
+plt.style.use('default')
+plt.rcParams['font.family'] = 'DejaVu Sans'  # Для поддержки кириллицы
+
+
+def load_and_analyze_data():
+    """Загрузка и базовый анализ данных"""
+
+    # Загрузка данных с правильным разделителем
+    file_path = 'small.csv'  # или полный путь к файлу
+
+    # Пробуем разные разделители и кодировки
+    try:
+        # Сначала пробуем с разделителем точка с запятой
+        df = pd.read_csv(file_path, encoding='utf-8', delimiter=';')
+        print("✅ Файл загружен с разделителем ';' и кодировкой utf-8")
+    except:
+        try:
+            df = pd.read_csv(file_path, encoding='cp1251', delimiter=';')
+            print("✅ Файл загружен с разделителем ';' и кодировкой cp1251")
+        except:
+            try:
+                df = pd.read_csv(file_path, encoding='utf-8', delimiter=',')
+                print("✅ Файл загружен с разделителем ',' и кодировкой utf-8")
+            except:
+                try:
+                    df = pd.read_csv(file_path, encoding='cp1251', delimiter=',')
+                    print("✅ Файл загружен с разделителем ',' и кодировкой cp1251")
+                except Exception as e:
+                    print(f"❌ Ошибка загрузки файла: {e}")
+                    return None
+
+    print("=" * 60)
+    print("АНАЛИЗ РЕЗУЛЬТАТОВ АВТОМАТИЧЕСКОЙ ОЦЕНКИ")
+    print("=" * 60)
+
+    # Базовая информация о данных
+    print(f"Размер данных: {df.shape[0]} строк, {df.shape[1]} колонок")
+    print(f"\nВсе колонки: {list(df.columns)}")
+
+    # Показываем первые несколько строк для проверки
+    print(f"\nПервые 3 строки данных:")
+    print(df.head(3))
+
+    return df
+
+
+def check_and_rename_columns(df):
+    """Проверка и переименование колонок если нужно"""
+
+    print("\n" + "=" * 40)
+    print("ПРОВЕРКА СТРУКТУРЫ ДАННЫХ")
+    print("=" * 40)
+
+    # Если есть только одна колонка, возможно данные объединены
+    if df.shape[1] == 1:
+        first_column = df.columns[0]
+        print(f"Обнаружена одна колонка: '{first_column}'")
+
+        # Проверяем, содержит ли она все данные
+        sample_value = str(df.iloc[0, 0])
+        if ';' in sample_value:
+            print("⚠️  Данные объединены в одну колонку, разделяем...")
+
+            # Разделяем данные по точке с запятой
+            split_data = df[first_column].str.split(';', expand=True)
+
+            # Берем первую строку как заголовки
+            if split_data.shape[0] > 1:
+                new_columns = split_data.iloc[0].tolist()
+                split_data = split_data[1:]  # Убираем строку с заголовками
+                split_data.columns = new_columns
+                df = split_data.reset_index(drop=True)
+                print("✅ Данные успешно разделены")
+                print(f"Новые колонки: {list(df.columns)}")
+
+    return df
+
+
+def basic_statistics(df):
+    """Базовая статистика по оценкам"""
+
+    print("\n" + "=" * 40)
+    print("БАЗОВАЯ СТАТИСТИКА")
+    print("=" * 40)
+
+    # Проверяем наличие нужных колонок
+    available_columns = list(df.columns)
+    print(f"Доступные колонки: {available_columns}")
+
+    # Статистика по AI оценкам (pred_score)
+    if 'pred_score' in df.columns:
+        print("\nAI оценки (pred_score):")
+        print(f"  Среднее: {df['pred_score'].mean():.3f}")
+        print(f"  Медиана: {df['pred_score'].median():.3f}")
+        print(f"  Стандартное отклонение: {df['pred_score'].std():.3f}")
+        print(f"  Минимум: {df['pred_score'].min():.3f}")
+        print(f"  Максимум: {df['pred_score'].max():.3f}")
+    else:
+        print("❌ Колонка 'pred_score' не найдена")
+
+    # Статистика по человеческим оценкам
+    human_score_columns = ['Оценка экзаменатора', 'оценка', 'score', 'human_score']
+    human_score_col = None
+
+    for col in human_score_columns:
+        if col in df.columns:
+            human_score_col = col
+            break
+
+    if human_score_col:
+        print(f"\nОценки экзаменатора ({human_score_col}):")
+        print(f"  Среднее: {df[human_score_col].mean():.3f}")
+        print(f"  Медиана: {df[human_score_col].median():.3f}")
+        print(f"  Стандартное отклонение: {df[human_score_col].std():.3f}")
+
+        # Распределение оценок
+        print(f"\nРаспределение оценок экзаменатора:")
+        распределение = df[human_score_col].value_counts().sort_index()
+        for оценка, count in распределение.items():
+            print(f"  {оценка}: {count} ответов ({count / len(df) * 100:.1f}%)")
+    else:
+        print("❌ Колонка с оценками экзаменатора не найдена")
+
+
+def calculate_correlations(df):
+    """Расчет корреляций и разниц"""
+
+    print("\n" + "=" * 40)
+    print("КОРРЕЛЯЦИИ И РАСХОЖДЕНИЯ")
+    print("=" * 40)
+
+    # Проверяем наличие обеих колонок
+    if 'pred_score' not in df.columns:
+        print("❌ Колонка 'pred_score' не найдена для расчета корреляций")
+        return
+
+    human_score_columns = ['Оценка экзаменатора', 'оценка', 'score', 'human_score']
+    human_score_col = None
+
+    for col in human_score_columns:
+        if col in df.columns:
+            human_score_col = col
+            break
+
+    if not human_score_col:
+        print("❌ Колонка с оценками экзаменатора не найдена для расчета корреляций")
+        return
+
+    # Корреляция
+    correlation = df[[human_score_col, 'pred_score']].corr().iloc[0, 1]
+    print(f"Корреляция между оценками: {correlation:.3f}")
+
+    # Разницы между оценками
+    df['разница'] = df['pred_score'] - df[human_score_col]
+    df['abs_разница'] = abs(df['разница'])
+
+    print(f"\nСредняя абсолютная разница: {df['abs_разница'].mean():.3f}")
+    print(f"Максимальная разница: {df['abs_разница'].max():.3f}")
+    print(f"Минимальная разница: {df['abs_разница'].min():.3f}")
+
+    # Анализ согласованности
+    print("\nСОГЛАСОВАННОСТЬ ОЦЕНОК:")
+    for порог in [0.1, 0.3, 0.5, 1.0]:
+        согласованные = df[df['abs_разница'] < порог].shape[0]
+        процент = (согласованные / len(df)) * 100
+        print(f"  Разница < {порог}: {согласованные} ответов ({процент:.1f}%)")
+
+    # Направление разниц
+    завышение = len(df[df['разница'] > 0])
+    занижение = len(df[df['разница'] < 0])
+    совпадение = len(df[df['разница'] == 0])
+
+    print(f"\nНАПРАВЛЕНИЕ РАЗНИЦ:")
+    print(f"  AI завышает: {завышение} ({завышение / len(df) * 100:.1f}%)")
+    print(f"  AI занижает: {занижение} ({занижение / len(df) * 100:.1f}%)")
+    print(f"  Полное совпадение: {совпадение} ({совпадение / len(df) * 100:.1f}%)")
+
+
+def create_visualizations(df):
+    """Создание визуализаций"""
+
+    print("\n" + "=" * 40)
+    print("СОЗДАНИЕ ВИЗУАЛИЗАЦИЙ")
+    print("=" * 40)
+
+    # Проверяем наличие нужных колонок
+    if 'pred_score' not in df.columns:
+        print("❌ Колонка 'pred_score' не найдена для визуализации")
+        return
+
+    human_score_columns = ['Оценка экзаменатора', 'оценка', 'score', 'human_score']
+    human_score_col = None
+
+    for col in human_score_columns:
+        if col in df.columns:
+            human_score_col = col
+            break
+
+    if not human_score_col:
+        print("❌ Колонка с оценками экзаменатора не найдена для визуализации")
+        return
+
+    # Создаем папку для графиков
+    os.makedirs('graphs', exist_ok=True)
+
+    # 1. Scatter plot сравнения оценок
+    plt.figure(figsize=(12, 8))
+    scatter = plt.scatter(df[human_score_col], df['pred_score'],
+                          c=df['abs_разница'], cmap='viridis', alpha=0.7, s=80)
+    plt.colorbar(scatter, label='Абсолютная разница')
+
+    # Определяем диапазон для линии идеального соответствия
+    min_val = min(df[human_score_col].min(), df['pred_score'].min())
+    max_val = max(df[human_score_col].max(), df['pred_score'].max())
+    plt.plot([min_val, max_val], [min_val, max_val], 'r--', alpha=0.5, label='Идеальное соответствие')
+
+    plt.xlabel(f'Оценка экзаменатора ({human_score_col})', fontsize=12)
+    plt.ylabel('AI оценка (pred_score)', fontsize=12)
+    plt.title('Сравнение человеческой и AI оценки\n(цвет показывает величину расхождения)', fontsize=14)
+    plt.legend()
+    plt.grid(True, alpha=0.3)
+    plt.savefig('graphs/scatter_comparison.png', dpi=300, bbox_inches='tight')
+    plt.close()
+
+    # 2. Гистограмма разниц
+    plt.figure(figsize=(12, 6))
+    n, bins, patches = plt.hist(df['разница'], bins=30, alpha=0.7,
+                                edgecolor='black', color='skyblue')
+    plt.xlabel('Разница оценок (AI - Человек)', fontsize=12)
+    plt.ylabel('Количество ответов', fontsize=12)
+    plt.title('Распределение разниц между AI и человеческими оценками', fontsize=14)
+    plt.grid(True, alpha=0.3)
+    plt.axvline(x=0, color='red', linestyle='--', alpha=0.8, linewidth=2, label='Нулевая разница')
+    plt.axvline(x=df['разница'].mean(), color='orange', linestyle='--',
+                alpha=0.8, linewidth=2, label=f'Средняя разница: {df["разница"].mean():.3f}')
+    plt.legend()
+    plt.savefig('graphs/difference_histogram.png', dpi=300, bbox_inches='tight')
+    plt.close()
+
+    print("✅ Графики сохранены в папку 'graphs/'")
+
+
+def analyze_extreme_cases(df):
+    """Анализ крайних случаев"""
+
+    print("\n" + "=" * 40)
+    print("АНАЛИЗ КРАЙНИХ СЛУЧАЕВ")
+    print("=" * 40)
+
+    if 'abs_разница' not in df.columns:
+        print("❌ Не найдены данные о разницах оценок")
+        return
+
+    human_score_columns = ['Оценка экзаменатора', 'оценка', 'score', 'human_score']
+    human_score_col = None
+
+    for col in human_score_columns:
+        if col in df.columns:
+            human_score_col = col
+            break
+
+    if not human_score_col:
+        print("❌ Колонка с оценками экзаменатора не найдена")
+        return
+
+    # Наибольшие расхождения
+    большие_расхождения = df.nlargest(8, 'abs_разница')[
+        [human_score_col, 'pred_score', 'abs_разница', 'разница']
+    ]
+
+    # Добавляем ID если есть
+    id_columns = ['Id экзамена', 'id', 'ID', 'exam_id']
+    for col in id_columns:
+        if col in df.columns:
+            большие_расхождения[col] = df.loc[большие_расхождения.index, col]
+            break
+
+    question_columns = ['№ вопроса', 'question', 'вопрос', 'question_id']
+    for col in question_columns:
+        if col in df.columns:
+            большие_расхождения[col] = df.loc[большие_расхождения.index, col]
+            break
+
+    print("Топ-8 наибольших расхождений:")
+    print("-" * 80)
+    for idx, row in большие_расхождения.iterrows():
+        направление = "ЗАВЫШЕНИЕ" if row['разница'] > 0 else "ЗАНИЖЕНИЕ"
+
+        # Формируем информацию об ID и вопросе
+        id_info = ""
+        if 'Id экзамена' in row:
+            id_info = f"Экзамен {row['Id экзамена']}"
+        elif 'id' in row:
+            id_info = f"ID {row['id']}"
+
+        question_info = ""
+        if '№ вопроса' in row:
+            question_info = f", Вопрос {row['№ вопроса']}"
+        elif 'question' in row:
+            question_info = f", Вопрос {row['question']}"
+
+        print(f"\n📊 {id_info}{question_info} ({направление}):")
+        print(f"   👤 Человек: {row[human_score_col]} | 🤖 AI: {row['pred_score']:.3f}")
+        print(f"   📏 Разница: {row['abs_разница']:.3f} ({row['разница']:+.3f})")
+        print("-" * 60)
+
+
+def analyze_explanations(df):
+    """Анализ объяснений оценок"""
+
+    print("\n" + "=" * 40)
+    print("АНАЛИЗ ОБЪЯСНЕНИЙ ОЦЕНОК")
+    print("=" * 40)
+
+    explanation_columns = ['объяснение_оценки', 'explanation', 'объяснение', 'комментарий']
+    explanation_col = None
+
+    for col in explanation_columns:
+        if col in df.columns:
+            explanation_col = col
+            break
+
+    if not explanation_col:
+        print("❌ Колонка с объяснениями оценок не найдена")
+        return
+
+    # Собираем все объяснения
+    все_объяснения = ' '.join(df[explanation_col].dropna().astype(str))
+
+    # Разбиваем на слова и фил��труем
+    слова = [word.strip() for word in все_объяснения.split() if len(word.strip()) > 2]
+
+    # Анализ частотности
+    частотность = Counter(слова)
+
+    print("Топ-15 наиболее частых характеристик в объяснениях:")
+    print("-" * 50)
+    for слово, count in частотность.most_common(15):
+        print(f"  {слово}: {count}")
+
+
+def save_detailed_analysis(df):
+    """Сохранение детального анализа в файл"""
+
+    print("\n" + "=" * 40)
+    print("СОХРАНЕНИЕ РЕЗУЛЬТАТОВ")
+    print("=" * 40)
+
+    if 'abs_разница' not in df.columns:
+        print("❌ Нет данных для детального анализа")
+        return
+
+    # Создаем копию с анализом
+    df_analysis = df.copy()
+
+    human_score_columns = ['Оценка экзаменатора', 'оценка', 'score', 'human_score']
+    human_score_col = None
+
+    for col in human_score_columns:
+        if col in df.columns:
+            human_score_col = col
+            break
+
+    if human_score_col and 'pred_score' in df.columns:
+        df_analysis['разница_ai_человек'] = df_analysis['pred_score'] - df_analysis[human_score_col]
+        df_analysis['abs_разница'] = abs(df_analysis['разница_ai_человек'])
+
+        # Добавляем категоризацию расхождений
+        условия = [
+            df_analysis['abs_разница'] < 0.1,
+            df_analysis['abs_разница'] < 0.3,
+            df_analysis['abs_разница'] < 0.5,
+            df_analysis['abs_разница'] >= 0.5
+        ]
+        категории = ['Отличное', 'Хорошее', 'Умеренное', 'Низкое']
+        df_analysis['качество_согласования'] = np.select(условия, категории, default='Низкое')
+
+        # Сортируем по наибольшим расхождениям
+        df_analysis = df_analysis.sort_values('abs_разница', ascending=False)
+
+    try:
+        # Сохраняем в Excel
+        with pd.ExcelWriter('detailed_analysis.xlsx', engine='openpyxl') as writer:
+            # Все данные
+            df_analysis.to_excel(writer, sheet_name='Все_данные_с_анализом', index=False)
+            print("✅ Детальный анализ сохранен в 'detailed_analysis.xlsx'")
+
+    except Exception as e:
+        print(f"⚠️  Не удалось сохранить Excel, сохраняем в CSV: {e}")
+        df_analysis.to_csv('detailed_analysis.csv', index=False, encoding='utf-8')
+        print("✅ Детальный анализ сохранен в 'detailed_analysis.csv'")
+
+
+def main():
+    """Основная функция"""
+
+    try:
+        # Загрузка данных
+        df = load_and_analyze_data()
+
+        if df is None:
+            return
+
+        # Проверка и корректировка структуры данных
+        df = check_and_rename_columns(df)
+
+        # Выполнение анализа
+        basic_statistics(df)
+        calculate_correlations(df)
+        create_visualizations(df)
+        analyze_extreme_cases(df)
+        analyze_explanations(df)
+        save_detailed_analysis(df)
+
+        print("\n" + "=" * 60)
+        print("✅ АНАЛИЗ ЗАВЕРШЕН!")
+        print("=" * 60)
+
+    except FileNotFoundError:
+        print("❌ ОШИБКА: Файл 'small.csv' не найден в текущей директории")
+        print("   Убедитесь, что файл находится в той же папке, что и скрипт")
+    except Exception as e:
+        print(f"❌ ОШИБКА при выполнении анализа: {str(e)}")
+        import traceback
+        traceback.print_exc()
+
+
+if __name__ == "__main__":
+    main()

analyze_results_pro.py

@@ -0,0 +1,440 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+from collections import Counter
+import numpy as np
+import os
+import warnings
+
+warnings.filterwarnings('ignore')
+
+# Настройка отображения
+plt.style.use('default')
+plt.rcParams['font.family'] = 'DejaVu Sans'
+
+
+def load_and_analyze_data():
+    """Загрузка и базовый анализ данных"""
+
+    file_path = 'small.csv'
+
+    try:
+        df = pd.read_csv(file_path, encoding='utf-8', delimiter=';')
+        print("Файл загружен с разделителем ';' и кодировкой utf-8")
+    except:
+        try:
+            df = pd.read_csv(file_path, encoding='cp1251', delimiter=';')
+            print("Файл загружен с разделителем ';' и кодировкой cp1251")
+        except:
+            try:
+                df = pd.read_csv(file_path, encoding='utf-8', delimiter=',')
+                print("Файл загружен с разделителем ',' и кодировкой utf-8")
+            except:
+                try:
+                    df = pd.read_csv(file_path, encoding='cp1251', delimiter=',')
+                    print("Файл загружен с разделителем ',' и кодировкой cp1251")
+                except Exception as e:
+                    print(f"Ошибка загрузки файла: {e}")
+                    return None
+
+    print("=" * 60)
+    print("АНАЛИЗ РЕЗУЛЬТАТОВ АВТОМАТИЧЕСКОЙ ОЦЕНКИ")
+    print("=" * 60)
+
+    print(f"Размер данных: {df.shape[0]} строк, {df.shape[1]} колонок")
+    print(f"Колонки: {list(df.columns)}")
+
+    return df
+
+
+def basic_statistics(df):
+    """Базовая статистика по оценкам"""
+
+    print("\n" + "=" * 40)
+    print("БАЗОВАЯ СТАТИСТИКА")
+    print("=" * 40)
+
+    # Статистика по AI оценкам
+    print("AI оценки (pred_score):")
+    print(f"  Среднее: {df['pred_score'].mean():.3f}")
+    print(f"  Медиана: {df['pred_score'].median():.3f}")
+    print(f"  Стандартное отклонение: {df['pred_score'].std():.3f}")
+    print(f"  Минимум: {df['pred_score'].min():.3f}")
+    print(f"  Максимум: {df['pred_score'].max():.3f}")
+
+    # Статистика по человеческим оценкам
+    print("\nОценки экзаменатора:")
+    print(f"  Среднее: {df['Оценка экзаменатора'].mean():.3f}")
+    print(f"  Медиана: {df['Оценка экзаменатора'].median():.3f}")
+    print(f"  Стандартное отклонение: {df['Оценка экзаменатора'].std():.3f}")
+
+    # Распределение оценок
+    print("\nРаспределение оценок экзаменатора:")
+    распределение = df['Оценка экзаменатора'].value_counts().sort_index()
+    for оценка, count in распределение.items():
+        print(f"  {оценка}: {count} ответов ({count / len(df) * 100:.1f}%)")
+
+
+def calculate_correlations(df):
+    """Расчет корреляций и разниц"""
+
+    print("\n" + "=" * 40)
+    print("КОРРЕЛЯЦИИ И РАСХОЖДЕНИЯ")
+    print("=" * 40)
+
+    # Корреляция
+    correlation = df[['Оценка экзаменатора', 'pred_score']].corr().iloc[0, 1]
+    print(f"Корреляция между оценками: {correlation:.3f}")
+
+    # Разницы между оценками
+    df['разница'] = df['pred_score'] - df['Оценка экзаменатора']
+    df['abs_разница'] = abs(df['разница'])
+
+    print(f"Средняя абсолютная разница: {df['abs_разница'].mean():.3f}")
+    print(f"Максимальная разница: {df['abs_разница'].max():.3f}")
+    print(f"Минимальная разница: {df['abs_разница'].min():.3f}")
+
+    # Анализ согласованности
+    print("\nСОГЛАСОВАННОСТЬ ОЦЕНОК:")
+    for порог in [0.1, 0.3, 0.5, 1.0]:
+        согласованные = df[df['abs_разница'] < порог].shape[0]
+        процент = (согласованные / len(df)) * 100
+        print(f"  Разница < {порог}: {согласованные} ответов ({процент:.1f}%)")
+
+    # Направление разниц
+    завышение = len(df[df['разница'] > 0])
+    занижение = len(df[df['разница'] < 0])
+    совпадение = len(df[df['разница'] == 0])
+
+    print(f"\nНАПРАВЛЕНИЕ РАЗНИЦ:")
+    print(f"  AI завышает: {завышение} ({завышение / len(df) * 100:.1f}%)")
+    print(f"  AI занижает: {занижение} ({занижение / len(df) * 100:.1f}%)")
+    print(f"  Полное совпадение: {совпадение} ({совпадение / len(df) * 100:.1f}%)")
+
+
+def create_visualizations(df):
+    """Создание визуализаций"""
+
+    print("\n" + "=" * 40)
+    print("СОЗДАНИЕ ВИЗУАЛИЗАЦИЙ")
+    print("=" * 40)
+
+    # Создаем папку для графиков
+    os.makedirs('graphs', exist_ok=True)
+
+    # 1. Scatter plot сравнения оценок
+    plt.figure(figsize=(12, 8))
+    scatter = plt.scatter(df['Оценка экзаменатора'], df['pred_score'],
+                          c=df['abs_разница'], cmap='viridis', alpha=0.7, s=80)
+    plt.colorbar(scatter, label='Абсолютная разница')
+    plt.plot([0, 2], [0, 2], 'r--', alpha=0.5, label='Идеальное соответствие')
+    plt.xlabel('Оценка экзаменатора', fontsize=12)
+    plt.ylabel('AI оценка (pred_score)', fontsize=12)
+    plt.title('Сравнение человеческой и AI оценки', fontsize=14)
+    plt.legend()
+    plt.grid(True, alpha=0.3)
+    plt.xticks([0, 1, 2])
+    plt.yticks(np.arange(0, 2.5, 0.5))
+    plt.savefig('graphs/scatter_comparison_pro.png', dpi=300, bbox_inches='tight')
+    plt.close()
+
+    # 2. Гистограмма разниц
+    plt.figure(figsize=(12, 6))
+    n, bins, patches = plt.hist(df['разница'], bins=30, alpha=0.7,
+                                edgecolor='black', color='skyblue')
+    plt.xlabel('Разница оценок (AI - Человек)', fontsize=12)
+    plt.ylabel('Количество ответов', fontsize=12)
+    plt.title('Распределение разниц между AI и человеческими оценками', fontsize=14)
+    plt.grid(True, alpha=0.3)
+    plt.axvline(x=0, color='red', linestyle='--', alpha=0.8, linewidth=2, label='Нулевая разница')
+    plt.axvline(x=df['разница'].mean(), color='orange', linestyle='--',
+                alpha=0.8, linewidth=2, label=f'Средняя разница: {df["разница"].mean():.3f}')
+    plt.legend()
+    plt.savefig('graphs/difference_histogram_pro.png', dpi=300, bbox_inches='tight')
+    plt.close()
+
+    # 3. Box plot по типам вопросов
+    plt.figure(figsize=(14, 8))
+    box_data = [df[df['№ вопроса'] == question]['pred_score'].values
+                for question in sorted(df['№ вопроса'].unique())]
+
+    box_plot = plt.boxplot(box_data, labels=sorted(df['№ вопроса'].unique()),
+                           patch_artist=True)
+
+    # Раскрашиваем boxplot
+    colors = ['lightblue', 'lightgreen', 'lightcoral', 'lightyellow']
+    for patch, color in zip(box_plot['boxes'], colors):
+        patch.set_facecolor(color)
+
+    plt.title('Распределение AI оценок по номерам вопросов', fontsize=14)
+    plt.xlabel('Номер вопроса', fontsize=12)
+    plt.ylabel('AI оценка (pred_score)', fontsize=12)
+    plt.grid(True, alpha=0.3)
+    plt.savefig('graphs/question_boxplot_pro.png', dpi=300, bbox_inches='tight')
+    plt.close()
+
+    print("Графики сохранены в папку 'graphs/'")
+
+
+def analyze_extreme_cases(df):
+    """Анализ крайних случаев"""
+
+    print("\n" + "=" * 40)
+    print("АНАЛИЗ КРАЙНИХ СЛУЧАЕВ")
+    print("=" * 40)
+
+    # Наибольшие расхождения
+    большие_расхождения = df.nlargest(8, 'abs_разница')[
+        ['Id экзамена', '№ вопроса', 'Оценка экзаменатора', 'pred_score',
+         'abs_разница', 'разница']
+    ]
+
+    print("Топ-8 наибольших расхождений:")
+    print("-" * 80)
+    for idx, row in большие_расхождения.iterrows():
+        направление = "ЗАВЫШЕНИЕ" if row['разница'] > 0 else "ЗАНИЖЕНИЕ"
+        print(f"\nЭкзамен {row['Id экзамена']}, Вопрос {row['№ вопроса']} ({направление}):")
+        print(f"  Человек: {row['Оценка экзаменатора']} | AI: {row['pred_score']:.3f}")
+        print(f"  Разница: {row['abs_разница']:.3f} ({row['разница']:+.3f})")
+        print("-" * 60)
+
+
+def analyze_explanations(df):
+    """Анализ объяснений оценок"""
+
+    print("\n" + "=" * 40)
+    print("АНАЛИЗ ОБЪЯСНЕНИЙ ОЦЕНОК")
+    print("=" * 40)
+
+    explanation_columns = ['объяснение_оценки', 'explanation', 'объяснение']
+    explanation_col = None
+
+    for col in explanation_columns:
+        if col in df.columns:
+            explanation_col = col
+            break
+
+    if not explanation_col:
+        print("Колонка с объяснениями оценок не найдена")
+        return
+
+    # Собираем все объяснения
+    все_объяснения = ' '.join(df[explanation_col].dropna().astype(str))
+
+    # Разбиваем на слова и фильтруем
+    слова = [word.strip() for word in все_объяснения.split() if len(word.strip()) > 2]
+
+    # Анализ частотности
+    частотность = Counter(слова)
+
+    print("Топ-15 наиболее частых характеристик в объяснениях:")
+    for слово, count in частотность.most_common(15):
+        print(f"  {слово}: {count}")
+
+    # Анализ по ключевым категориям
+    категории = {
+        'Развернутый': 'Развернутый ответ',
+        'смысловое': 'Смысловое соответствие',
+        'соответствие': 'Смысловое соответствие',
+        'Хорошая': 'Хорошая структура',
+        'структура': 'Хорошая структура',
+        'лексика': 'Разнообразная лексика',
+        'Высокий': 'Высокий балл',
+        'балл': 'Высокий балл',
+        'описание': 'Подробное описание',
+        'личный': 'Личный опыт',
+        'покрытие': 'Покрытие вопросов'
+    }
+
+    print(f"\nСТАТИСТИКА ПО КАТЕГОРИЯМ:")
+    for ключ, описание in категориями.items():
+        count = sum(1 for слово in слова if ключ in слово)
+        if count > 0:
+            print(f"  {описание}: {count}")
+
+
+def performance_by_question_type(df):
+    """Анализ производительности по типам вопросов"""
+
+    print("\n" + "=" * 40)
+    print("АНАЛИЗ ПО ТИПАМ ВОПРОСОВ")
+    print("=" * 40)
+
+    вопросы_статистика = df.groupby('№ вопроса').agg({
+        'Оценка экзаменатора': ['mean', 'std', 'count'],
+        'pred_score': ['mean', 'std'],
+        'abs_разница': 'mean',
+        'разница': 'mean'
+    }).round(3)
+
+    # Переименовываем колонки для удобства
+    вопросы_статистика.columns = ['чел_среднее', 'чел_стд', 'количество',
+                                  'ai_среднее', 'ai_стд', 'ср_абс_разница', 'ср_разница']
+
+    вопросы_статистика['расхождение'] = abs(вопросы_статистика['ср_разница'])
+
+    print("СТАТИСТИКА ПО ВОПРОСАМ:")
+    print("-" * 80)
+    print(f"{'Вопрос':<6} {'Чел.ср':<8} {'AI ср':<8} {'Разн.':<8} {'Кол-во':<8} {'Описание'}")
+    print("-" * 80)
+
+    for вопрос, row in вопросы_статистика.iterrows():
+        разница_знак = "+" if row['ср_разница'] > 0 else ""
+        print(f"{вопрос:<6} {row['чел_среднее']:<8} {row['ai_среднее']:<8} "
+              f"{разница_знак}{row['ср_разница']:<7} {int(row['количество']):<8} ", end="")
+
+        if row['расхождение'] > 0.3:
+            print("ВНИМАНИЕ: большое расхождение")
+        elif row['расхождение'] > 0.1:
+            print("Умеренное расхождение")
+        else:
+            print("Хорошее соответствие")
+
+
+def save_detailed_analysis(df):
+    """Сохранение детального анализа в файл"""
+
+    print("\n" + "=" * 40)
+    print("СОХРАНЕНИЕ РЕЗУЛЬТАТОВ")
+    print("=" * 40)
+
+    # Создаем копию с анализом
+    df_analysis = df.copy()
+    df_analysis['разница_ai_человек'] = df_analysis['pred_score'] - df_analysis['Оценка экзаменатора']
+    df_analysis['abs_разница'] = abs(df_analysis['разница_ai_человек'])
+
+    # Добавляем категоризацию расхождений
+    условия = [
+        df_analysis['abs_разница'] < 0.1,
+        df_analysis['abs_разница'] < 0.3,
+        df_analysis['abs_разница'] < 0.5,
+        df_analysis['abs_разница'] >= 0.5
+    ]
+    категории = ['Отличное', 'Хорошее', 'Умеренное', 'Низкое']
+    df_analysis['качество_согласования'] = np.select(условия, категории, default='Низкое')
+
+    # Сортируем по наибольшим расхождениям
+    df_analysis = df_analysis.sort_values('abs_разница', ascending=False)
+
+    try:
+        # Сохраняем в Excel
+        with pd.ExcelWriter('detailed_analysis_pro.xlsx', engine='openpyxl') as writer:
+            # Все данные
+            df_analysis.to_excel(writer, sheet_name='Все_данные_с_анализом', index=False)
+
+            # Сводная та��лица по вопросам
+            сводная = df_analysis.groupby('№ вопроса').agg({
+                'Оценка экзаменатора': ['mean', 'std', 'min', 'max'],
+                'pred_score': ['mean', 'std', 'min', 'max'],
+                'abs_разница': ['mean', 'max'],
+                'разница_ai_человек': 'mean',
+                'Id экзамена': 'count'
+            }).round(3)
+            сводная.to_excel(writer, sheet_name='Сводка_по_вопросам')
+
+            # Наибольшие расхождения
+            большие_расхождения = df_analysis.nlargest(20, 'abs_разница')[
+                ['Id экзамена', '№ вопроса', 'Оценка экзаменатора',
+                 'pred_score', 'разница_ai_человек', 'abs_разница']
+            ]
+            большие_расхождения.to_excel(writer, sheet_name='Наибольшие_расхождения', index=False)
+
+            # Статистика по качеству согласования
+            качество_стат = df_analysis['качество_согласования'].value_counts()
+            качество_стат.to_excel(writer, sheet_name='Качество_согласования')
+
+        print("Детальный анализ сохранен в 'detailed_analysis_pro.xlsx'")
+
+    except Exception as e:
+        print(f"Не удалось сохранить Excel, сохраняем в CSV: {e}")
+        df_analysis.to_csv('detailed_analysis_pro.csv', index=False, encoding='utf-8')
+        print("Детальный анализ сохранен в 'detailed_analysis_pro.csv'")
+
+
+def generate_summary_report(df):
+    """Генерация итогового отчета"""
+
+    print("\n" + "=" * 60)
+    print("ИТОГОВЫЙ ОТЧЕТ")
+    print("=" * 60)
+
+    корреляция = df[['Оценка экзаменатора', 'pred_score']].corr().iloc[0, 1]
+    ср_разница = df['abs_разница'].mean()
+
+    print(f"\nОБЩАЯ СТАТИСТИКА:")
+    print(f"  Всего ответов: {len(df)}")
+    print(f"  Корреляция AI-Человек: {корреляция:.3f}")
+    print(f"  Средняя абсолютная разница: {ср_разница:.3f}")
+
+    # Оценка качества
+    if корреляция > 0.8 and ср_разница < 0.2:
+        оценка = "ОТЛИЧНОЕ"
+    elif корреляция > 0.6 and ср_разница < 0.3:
+        оценка = "ХОРОШЕЕ"
+    elif корреляция > 0.4 and ср_разница < 0.4:
+        оценка = "УДОВЛЕТВОРИТЕЛЬНОЕ"
+    else:
+        оценка = "НИЗКОЕ"
+
+    print(f"\nОЦЕНКА КАЧЕСТВА СИСТЕМЫ: {оценка}")
+
+    # Рекомендации
+    print(f"\nРЕКОМЕНДАЦИИ:")
+    if ср_разница > 0.3:
+        print("  Проанализировать систематические ошибки в оценках")
+    if корреляция < 0.6:
+        print("  Улучшить согласованность с человеческими оценками")
+
+    # Лучшие и худшие вопросы
+    вопросы_стат = df.groupby('№ вопроса')['abs_разница'].mean().sort_values()
+    лучший_вопрос = вопросы_стат.index[0]
+    худший_вопрос = вопросы_стат.index[-1]
+
+    print(f"\nЛУЧШИЙ ВОПРОС ПО СОГЛАСОВАННОСТИ: №{лучший_вопрос} (разница: {вопросы_стат.iloc[0]:.3f})")
+    print(f"ХУДШИЙ ВОПРОС ПО СОГЛАСОВАННОСТИ: №{худший_вопрос} (разница: {вопросы_стат.iloc[-1]:.3f})")
+
+
+def main():
+    """Основная функция"""
+
+    try:
+        # Загрузка данных
+        df = load_and_analyze_data()
+
+        if df is None:
+            return
+
+        # Проверка необходимых колонок
+        required_columns = ['Оценка экзаменатора', 'pred_score', '№ вопроса']
+        missing_columns = [col for col in required_columns if col not in df.columns]
+
+        if missing_columns:
+            print(f"ОШИБКА: Отсутствуют колонки: {missing_columns}")
+            return
+
+        # Выполнение анализа
+        basic_statistics(df)
+        calculate_correlations(df)
+        create_visualizations(df)
+        analyze_extreme_cases(df)
+        analyze_explanations(df)
+        performance_by_question_type(df)
+        save_detailed_analysis(df)
+        generate_summary_report(df)
+
+        print("\n" + "=" * 60)
+        print("АНАЛИЗ ЗАВЕРШЕН!")
+        print("=" * 60)
+        print("\nСОЗДАННЫЕ ФАЙЛЫ:")
+        print("  graphs/scatter_comparison_pro.png - сравнение оц��нок")
+        print("  graphs/difference_histogram_pro.png - распределение разниц")
+        print("  graphs/question_boxplot_pro.png - оценки по вопросам")
+        print("  detailed_analysis_pro.xlsx - детальный отчет")
+
+    except FileNotFoundError:
+        print("ОШИБКА: Файл 'small.csv' не найден в текущей директории")
+    except Exception as e:
+        print(f"ОШИБКА при выполнении анализа: {str(e)}")
+
+
+if __name__ == "__main__":
+    main()

analyze_test.py

@@ -0,0 +1,165 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+from collections import Counter
+import numpy as np
+import os
+import warnings
+
+warnings.filterwarnings('ignore')
+
+# Настройка отображения
+plt.style.use('default')
+plt.rcParams['font.family'] = 'DejaVu Sans'
+
+
+def load_and_analyze_data():
+    """Загрузка тестовых данных"""
+
+    file_path = 'test_data.csv'
+
+    try:
+        df = pd.read_csv(file_path, encoding='utf-8', delimiter=';')
+        print("✅ Тестовый файл загружен успешно")
+    except Exception as e:
+        print(f"❌ Ошибка загрузки: {e}")
+        print("Убедитесь, что файл test_data.csv находится в той же папке")
+        return None
+
+    print("=" * 60)
+    print("ТЕСТОВЫЙ АНАЛИЗ AI-ОЦЕНОК")
+    print("=" * 60)
+
+    print(f"Размер данных: {df.shape[0]} строк, {df.shape[1]} колонок")
+    print(f"Колонки: {list(df.columns)}")
+    print(f"\nПервые 3 строки:")
+    print(df.head(3))
+
+    return df
+
+
+def basic_statistics(df):
+    """Базовая статистика"""
+
+    print("\n" + "=" * 40)
+    print("БАЗОВАЯ СТАТИСТИКА")
+    print("=" * 40)
+
+    print("AI оценки (pred_score):")
+    print(f"  Среднее: {df['pred_score'].mean():.3f}")
+    print(f"  Медиана: {df['pred_score'].median():.3f}")
+    print(f"  Стандартное отклонение: {df['pred_score'].std():.3f}")
+    print(f"  Минимум: {df['pred_score'].min():.3f}")
+    print(f"  Максимум: {df['pred_score'].max():.3f}")
+
+    print("\nОценки экзаменатора:")
+    print(f"  Среднее: {df['Оценка экзаменатора'].mean():.3f}")
+    print(f"  Медиана: {df['Оценка экзаменатора'].median():.3f}")
+    print(f"  Стандартное отклонение: {df['Оценка экзаменатора'].std():.3f}")
+
+    print("\nРаспределение оценок экзаменатора:")
+    распределение = df['Оценка экзаменатора'].value_counts().sort_index()
+    for оценка, count in распределение.items():
+        print(f"  {оценка}: {count} ответов ({count / len(df) * 100:.1f}%)")
+
+
+def calculate_correlations(df):
+    """Расчет корреляций"""
+
+    print("\n" + "=" * 40)
+    print("КОРРЕЛЯЦИИ И РАСХОЖДЕНИЯ")
+    print("=" * 40)
+
+    correlation = df[['Оценка экзаменатора', 'pred_score']].corr().iloc[0, 1]
+    print(f"Корреляция между оценками: {correlation:.3f}")
+
+    df['разница'] = df['pred_score'] - df['Оценка экзаменатора']
+    df['abs_разница'] = abs(df['разница'])
+
+    print(f"Средняя абсолютная разница: {df['abs_разница'].mean():.3f}")
+    print(f"Максимальная разница: {df['abs_разница'].max():.3f}")
+    print(f"Минимальная разница: {df['abs_разница'].min():.3f}")
+
+    # Анализ согласованности
+    print("\nСОГЛАСОВАННОСТЬ ОЦЕНОК:")
+    for порог in [0.1, 0.3, 0.5, 1.0]:
+        согласованные = df[df['abs_разница'] < порог].shape[0]
+        процент = (согласованные / len(df)) * 100
+        print(f"  Разница < {порог}: {согласованные} ответов ({процент:.1f}%)")
+
+
+def create_visualizations(df):
+    """Создание графиков"""
+
+    print("\n" + "=" * 40)
+    print("СОЗДАНИЕ ГРАФИКОВ")
+    print("=" * 40)
+
+    os.makedirs('graphs', exist_ok=True)
+
+    # 1. Scatter plot
+    plt.figure(figsize=(10, 6))
+    scatter = plt.scatter(df['Оценка экзаменатора'], df['pred_score'],
+                          c=df['abs_разница'], cmap='viridis', alpha=0.7, s=60)
+    plt.colorbar(scatter, label='Абсолютная разница')
+    plt.plot([0, 2], [0, 2], 'r--', alpha=0.5, label='Идеальное соответствие')
+    plt.xlabel('Оценка экзаменатора')
+    plt.ylabel('AI оценка (pred_score)')
+    plt.title('Сравнение человеческой и AI оценки')
+    plt.legend()
+    plt.grid(True, alpha=0.3)
+    plt.savefig('graphs/test_scatter.png', dpi=300, bbox_inches='tight')
+    plt.close()
+
+    # 2. Гистограмма разниц
+    plt.figure(figsize=(10, 6))
+    plt.hist(df['разница'], bins=15, alpha=0.7, edgecolor='black', color='skyblue')
+    plt.xlabel('Разница (AI - Человек)')
+    plt.ylabel('Количество ответов')
+    plt.title('Распределение разниц оценок')
+    plt.grid(True, alpha=0.3)
+    plt.axvline(x=0, color='red', linestyle='--', alpha=0.8, label='Нулевая разница')
+    plt.legend()
+    plt.savefig('graphs/test_histogram.png', dpi=300, bbox_inches='tight')
+    plt.close()
+
+    print("✅ Графики сохранены в папку 'graphs/'")
+
+
+def analyze_explanations(df):
+    """Анализ объяснений"""
+
+    print("\n" + "=" * 40)
+    print("АНАЛИЗ ОБЪЯСНЕНИЙ")
+    print("=" * 40)
+
+    все_объяснения = ' '.join(df['объяснение_оценки'].dropna().astype(str))
+    слова = [word.strip() for word in все_объяснения.split() if len(word.strip()) > 2]
+    частотность = Counter(слова)
+
+    print("Топ-10 характеристик в объяснениях:")
+    for слово, count in частотность.most_common(10):
+        print(f"  {слово}: {count}")
+
+
+def main():
+    """Основная функция"""
+
+    df = load_and_analyze_data()
+    if df is None:
+        return
+
+    basic_statistics(df)
+    calculate_correlations(df)
+    create_visualizations(df)
+    analyze_explanations(df)
+
+    print("\n" + "=" * 60)
+    print("✅ ТЕСТОВЫЙ АНАЛИЗ ЗАВЕРШЕН!")
+    print("=" * 60)
+    print("📊 Созданные файлы:")
+    print("   • graphs/test_scatter.png")
+    print("   • graphs/test_histogram.png")
+
+
+if __name__ == "__main__":
+    main()

app.py

@@ -0,0 +1,128 @@
+# app.py
+import io
+import os
+from pathlib import Path
+
+import pandas as pd
+import streamlit as st
+
+# быстрый режим по умолчанию
+os.environ.setdefault("FAST_MODE", "1")
+
+# импорт основного пайплайна
+from src.predict import pipeline_infer
+
+# --- Конфигурация страницы ---
+st.set_page_config(page_title="Русский как иностранный – автооценка", layout="centered")
+
+st.title("Автооценка устных ответов (RFL • CatBoost + ruSBERT)")
+st.caption("Загрузите CSV входного формата и получите файл с колонками pred_score и pred_score_rounded.")
+
+# --- Информация о формате ---
+with st.expander("Формат входного CSV", expanded=False):
+    st.markdown(
+        """
+        Обязательные столбцы:
+        - **№ вопроса** (1..4)
+        - **Текст вопроса**
+        - **Транскрибация ответа**
+        - *(опционально)* **Оценка экзаменатора** — если есть, её не трогаем, добавим предсказания рядом.  
+
+        Разделитель — `;`, кодировка — UTF-8 (автоопределяется).
+        """
+    )
+
+# --- Пример шаблона CSV ---
+with st.expander("📄 Скачать шаблон CSV"):
+    demo = pd.DataFrame({
+        "№ вопроса": [1, 2],
+        "Текст вопроса": ["<p>Добро пожаловать...</p>", "<p>Опишите свой день...</p>"],
+        "Транскрибация ответа": ["Здравствуйте! Я приехал...", "Мой день начинается с..."],
+        "Оценка экзаменатора": [None, None],
+    })
+    st.dataframe(demo)
+    buf_tmpl = io.BytesIO()
+    demo.to_csv(buf_tmpl, index=False, sep=";", encoding="utf-8-sig")
+    st.download_button("⬇ Скачать шаблон CSV", buf_tmpl.getvalue(), "template.csv", "text/csv")
+
+# --- Функция загрузки и нормализации ---
+required = ["№ вопроса", "Текст вопроса", "Транскрибация ответа"]
+aliases = {
+    "номер вопроса": "№ вопроса",
+    "вопрос": "Текст вопроса",
+    "текст задания": "Текст вопроса",
+    "транскрибация": "Транскрибация ответа",
+    "транскрипт": "Транскрибация ответа",
+    "ответ": "Транскрибация ответа",
+}
+
+
+def load_and_normalize_csv(raw_bytes: bytes) -> pd.DataFrame:
+    import io
+    for sep in [";", ",", "\t"]:
+        try:
+            df = pd.read_csv(io.BytesIO(raw_bytes), sep=sep, engine="python")
+
+            # убрать возможные артефакты Git-конфликтов
+            if not df.empty and str(df.columns[0]).startswith("<<<"):
+                text = raw_bytes.decode("utf-8", errors="ignore")
+                lines = [ln for ln in text.splitlines() if not ln.startswith(("<<<", "===", ">>>"))]
+                df = pd.read_csv(io.StringIO("\n".join(lines)), sep=sep, engine="python")
+
+            # нормализация имён колонок
+            rename_map = {}
+            for c in list(df.columns):
+                key = str(c).strip().lower()
+                if key in aliases:
+                    rename_map[c] = aliases[key]
+            if rename_map:
+                df = df.rename(columns=rename_map)
+
+            return df
+        except Exception:
+            continue
+    raise ValueError("Не удалось прочитать CSV. Проверьте разделитель (';' или ',') и кодировку UTF-8.")
+
+
+# --- Основной интерфейс ---
+uploaded = st.file_uploader("Загрузите CSV", type=["csv"])
+slow = st.toggle("Медленный режим", value=False, help="Выключите для быстрой оценки (точность ≈ прежняя).")
+run = st.button("Посчитать")
+
+if uploaded and run:
+    try:
+        raw = uploaded.read()
+        df_in = load_and_normalize_csv(raw)
+
+        # проверка обязательных колонок
+        missing = [c for c in required if c not in df_in.columns]
+        if missing:
+            st.error(f"❌ В файле нет обязательных колонок: {missing}. Проверь заголовки и разделитель ';'.")
+            st.dataframe(df_in.head())
+            st.stop()
+
+        # сохраняем временно
+        tmp_in = Path("data/api_tmp/tmp_input.csv")
+        tmp_in.parent.mkdir(parents=True, exist_ok=True)
+        df_in.to_csv(tmp_in, index=False, sep=";", encoding="utf-8-sig")
+
+        # режим скорости
+        os.environ["FAST_MODE"] = "0" if slow else "1"
+
+        tmp_out = Path("data/api_tmp/tmp_output.csv")
+        with st.spinner("Считаем..."):
+            pipeline_infer(tmp_in, tmp_out)
+
+        df_out = pd.read_csv(tmp_out, sep=";", encoding="utf-8-sig")
+        st.success("✅ Готово!")
+        st.dataframe(df_out.head(20), use_container_width=True)
+
+        buf = io.BytesIO()
+        df_out.to_csv(buf, index=False, sep=";", encoding="utf-8-sig")
+        st.download_button("⬇ Скачать результат (CSV)", data=buf.getvalue(), file_name="predicted.csv", mime="text/csv")
+    except Exception as e:
+        st.exception(e)
+
+# --- Подвал ---
+st.markdown("---")
+st.caption("Модель: CatBoost Q1..Q4 + ruSBERT. Быстрый режим = FAST_MODE=1.")

app/main.py

@@ -0,0 +1,223 @@
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.responses import HTMLResponse, FileResponse
+from fastapi.staticfiles import StaticFiles
+import csv
+import os
+import tempfile
+from typing import List, Dict
+import re
+
+app = FastAPI(title="Russian Exam Auto Grader")
+
+# Монтируем статические файлы для веб-интерфейса
+app.mount("/static", StaticFiles(directory="static"), name="static")
+
+
+class ExamGrader:
+    def __init__(self):
+        self.setup_criteria()
+
+    def setup_criteria(self):
+        self.criteria = {
+            1: self._grade_question1,  # 0-1 балл
+            2: self._grade_question2,  # 0-2 балла
+            3: self._grade_question3,  # 0-1 балл
+            4: self._grade_question4  # 0-2 балла
+        }
+
+    def grade_answer(self, question_num: int, transcription: str) -> int:
+        """Основной метод оценки"""
+        if question_num not in self.criteria:
+            return 0
+        return self.criteria[question_num](transcription)
+
+    def _grade_question1(self, text: str) -> int:
+        """Оценка вопроса 1 - начало диалога"""
+        text_lower = text.lower().strip()
+
+        # Проверяем ключевые элементы диалога
+        has_greeting = any(word in text_lower for word in ['здравствуйте', 'добрый день', 'привет', 'здравствуй'])
+        has_request = any(word in text_lower for word in ['помогите', 'подскажите', 'нужно', 'хочу', 'могу'])
+        has_question = any(word in text_lower for word in ['как', 'что', 'где', 'когда', 'можно', 'сколько'])
+
+        # Должен быть развернутый ответ
+        words_count = len(text_lower.split())
+
+        score = 0
+        if has_greeting:
+            score += 0.3
+        if has_request:
+            score += 0.4
+        if has_question:
+            score += 0.3
+        if words_count > 15:
+            score += 0.2
+
+        return 1 if score >= 0.7 else 0
+
+    def _grade_question2(self, text: str) -> int:
+        """Оценка вопроса 2 - ответы на вопросы"""
+        sentences = self._split_sentences(text)
+
+        if len(sentences) < 2:
+            return 0
+
+        # Оцениваем полноту ответов
+        complete_sentences = 0
+        for sentence in sentences:
+            words = sentence.split()
+            if len(words) >= 4:  # Более-менее полное предложение
+                complete_sentences += 1
+
+        completeness_ratio = complete_sentences / len(sentences)
+
+        if completeness_ratio >= 0.8:
+            return 2
+        elif completeness_ratio >= 0.5:
+            return 1
+        else:
+            return 0
+
+    def _grade_question3(self, text: str) -> int:
+        """Оценка вопроса 3 - диалог-запрос"""
+        text_lower = text.lower().strip()
+
+        has_greeting = any(word in text_lower for word in ['здравствуйте', 'добрый день'])
+        has_request = any(word in text_lower for word in ['хочу', 'нужно', 'узнать', 'скажите', 'интересует'])
+        has_thanks = any(word in text_lower for word in ['спасибо', 'благодарю'])
+
+        score = 0
+        if has_greeting:
+            score += 0.3
+        if has_request:
+            score += 0.4
+        if has_thanks:
+            score += 0.3
+
+        return 1 if score >= 0.7 else 0
+
+    def _grade_question4(self, text: str) -> int:
+        """Оценка вопроса 4 - описание картинки"""
+        sentences = self._split_sentences(text)
+
+        if len(sentences) < 3:
+            return 0
+
+        # Ищем описательные элементы
+        descriptive_words = ['вижу', 'изображен', 'находится', 'стоит', 'сидит',
+                             'одежда', 'цвет', 'время года', 'место', 'деревья', 'дом']
+
+        descriptive_count = 0
+        for sentence in sentences:
+            if any(word in sentence.lower() for word in descriptive_words):
+                descriptive_count += 1
+
+        descriptive_ratio = descriptive_count / len(sentences)
+
+        if descriptive_ratio >= 0.6:
+            return 2
+        elif descriptive_ratio >= 0.3:
+            return 1
+        else:
+            return 0
+
+    def _split_sentences(self, text: str) -> List[str]:
+        """Разделяет текст на предложения"""
+        sentences = re.split(r'[.!?]+', text)
+        return [s.strip() for s in sentences if len(s.strip()) > 0]
+
+
+grader = ExamGrader()
+
+
+@app.post("/evaluate/")
+async def evaluate_file(file: UploadFile = File(...)):
+    try:
+        # Читаем CSV файл
+        content = await file.read()
+        decoded_content = content.decode('utf-8').splitlines()
+
+        # Парсим CSV
+        reader = csv.DictReader(decoded_content, delimiter=';')
+        rows = list(reader)
+
+        # Обрабатываем каждую строку
+        results = []
+        for row in rows:
+            try:
+                question_num = int(row['№ вопроса'])
+                transcription = row['Транскрибация ответа']
+
+                score = grader.grade_answer(question_num, transcription)
+
+                result_row = row.copy()
+                result_row['Оценка экзаменатора'] = score
+                results.append(result_row)
+            except (KeyError, ValueError) as e:
+                # Если есть ошибки в данных, ставим 0
+                result_row = row.copy()
+                result_row['Оценка экзаменатора'] = 0
+                results.append(result_row)
+
+        # Сохраняем результаты
+        output_filename = "graded_" + file.filename
+        with open(output_filename, 'w', newline='', encoding='utf-8') as f:
+            if results:
+                fieldnames = results[0].keys()
+                writer = csv.DictWriter(f, fieldnames=fieldnames, delimiter=';')
+                writer.writeheader()
+                writer.writerows(results)
+
+        return FileResponse(
+            output_filename,
+            media_type='text/csv',
+            filename=output_filename
+        )
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Ошибка обработки: {str(e)}")
+
+
+@app.get("/", response_class=HTMLResponse)
+async def main_page():
+    return """
+    <html>
+        <head>
+            <title>Russian Exam Auto Grader</title>
+            <style>
+                body { font-family: Arial, sans-serif; margin: 40px; }
+                .container { max-width: 600px; margin: 0 auto; }
+                .upload-form { border: 2px dashed #ccc; padding: 40px; text-align: center; }
+                .btn { background: #007bff; color: white; padding: 10px 20px; border: none; cursor: pointer; }
+                .btn:hover { background: #0056b3; }
+            </style>
+        </head>
+        <body>
+            <div class="container">
+                <h1>Russian Exam Auto Grader</h1>
+                <p>Загрузите CSV файл с ответами для автоматической оценки</p>
+
+                <form class="upload-form" action="/evaluate/" method="post" enctype="multipart/form-data">
+                    <input type="file" name="file" accept=".csv" required>
+                    <br><br>
+                    <button type="submit" class="btn">Оценить ответы</button>
+                </form>
+
+                <div style="margin-top: 30px;">
+                    <h3>Требования к файлу:</h3>
+                    <ul>
+                        <li>Формат: CSV с разделителем ";"</li>
+                        <li>Колонки: № вопроса, Транскрибация ответа</li>
+                        <li>Кодировка: UTF-8</li>
+                    </ul>
+                </div>
+            </div>
+        </body>
+    </html>
+    """
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=8000)

app/simple_ui.py

@@ -0,0 +1,52 @@
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+
+app = FastAPI()
+
+# Простой HTML интерфейс
+HTML_FORM = """
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Система оценки ответов</title>
+    <style>
+        body { font-family: Arial, sans-serif; margin: 40px; }
+        .container { max-width: 600px; margin: 0 auto; }
+        .upload-form { border: 2px dashed #ccc; padding: 20px; text-align: center; }
+        .btn { background: #007cba; color: white; padding: 10px 20px; border: none; cursor: pointer; }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>📝 Система автоматической оценки ответов</h1>
+        <p>Загрузите CSV файл с ответами студентов для оценки</p>
+
+        <form class="upload-form" action="/predict_csv" method="post" enctype="multipart/form-data">
+            <input type="file" name="file" accept=".csv" required>
+            <br><br>
+            <button type="submit" class="btn">Оценить ответы</button>
+        </form>
+
+        <div style="margin-top: 30px;">
+            <h3>API Endpoints:</h3>
+            <ul>
+                <li><a href="/health">Health Check</a></li>
+                <li><a href="/docs">API Documentation</a></li>
+            </ul>
+        </div>
+    </div>
+</body>
+</html>
+"""
+
+
+@app.get("/", response_class=HTMLResponse)
+async def main_page(request: Request):
+    return HTML_FORM
+
+
+@app.get("/ui")
+async def ui_page():
+    return HTMLResponse(HTML_FORM)

app/ui.py

@@ -0,0 +1,32 @@
+from fastapi import FastAPI, Request, UploadFile, File
+from fastapi.responses import HTMLResponse, StreamingResponse
+from fastapi.templating import Jinja2Templates
+import requests
+
+app = FastAPI(title="Scoring UI")
+templates = Jinja2Templates(directory="templates")
+
+# 🔧 Локальный адрес FastAPI-сервера
+API_URL = "http://localhost:8000/predict_csv"
+
+@app.get("/", response_class=HTMLResponse)
+async def home(request: Request):
+    return templates.TemplateResponse("index.html", {"request": request})
+
+@app.get("/health")
+async def health():
+    return {"status": "ok", "service": "scoring-ui"}
+
+@app.post("/predict")
+async def predict_csv(file: UploadFile = File(...)):
+    files = {"file": (file.filename, await file.read(), file.content_type)}
+    try:
+        resp = requests.post(API_URL, files=files, timeout=1800)
+        resp.raise_for_status()
+        return StreamingResponse(
+            iter([resp.content]),
+            media_type="text/csv",
+            headers={"Content-Disposition": f'attachment; filename="predicted_{file.filename}"'}
+        )
+    except Exception as e:
+        return {"error": str(e)}

assessment_engine.py

@@ -0,0 +1,46 @@
+# assessment_engine.py
+import pandas as pd
+
+# Импортируй твои шаги — подставь правильные модули:
+# from src.data_cleaning import prepare_dataframe
+# from src.features import build_baseline_features
+# from src.features_q4 import add_q4_features
+# from src.semantic_features import add_semantic_features
+# from src.explanations import build_explanations
+# from your_models_loader import load_models, predict_batch
+
+# Заглушка: здесь покажу форму, ты подставишь свои вызовы
+def run_inference_df(df: pd.DataFrame, with_explanations: bool = True) -> pd.DataFrame:
+    data = df.copy()
+
+    # 1) Очистка/нормализация
+    # data = prepare_dataframe(data)
+
+    # 2) Базовые фичи
+    # data = build_baseline_features(data)
+
+    # 3) Спецфичи для Q4
+    # data = add_q4_features(data)
+
+    # 4) Семантические фичи
+    # data = add_semantic_features(data)
+
+    # 5) Предсказания CatBoost по каждому вопросу
+    # models = load_models("models")  # твоя реализация
+    # data = predict_batch(data, models)  # должна добавить колонку predicted_score
+
+    # 6) Клип значений по диапазонам (на всякий случай)
+    if "question_number" in data.columns and "predicted_score" in data.columns:
+        def clip_score(row):
+            q = int(row["question_number"])
+            s = float(row["predicted_score"])
+            if q in (1, 3):
+                return int(min(1, max(0, round(s))))
+            return int(min(2, max(0, round(s))))
+        data["predicted_score"] = data.apply(clip_score, axis=1)
+
+    # 7) Объяснения (если есть)
+    # if with_explanations:
+    #     data = build_explanations(data)
+
+    return data

check_final_quality.py

@@ -0,0 +1,27 @@
+import pandas as pd
+import numpy as np
+from sklearn.metrics import mean_absolute_error
+
+# Читаем наши предсказания
+df = pd.read_csv('test_output.csv', delimiter=';', encoding='utf-8-sig')
+
+# Фильтруем только строки с истинными оценками
+df_with_truth = df[df['Оценка экзаменатора'].notna()]
+
+if len(df_with_truth) > 0:
+    true_scores = df_with_truth['Оценка экзаменатора']
+    pred_scores = df_with_truth['pred_score']
+
+    mae_total = mean_absolute_error(true_scores, pred_scores)
+    print(f'📊 ОБЩЕЕ КАЧЕСТВО (MAE): {mae_total:.3f} балла')
+    print()
+
+    # По типам вопросов
+    for q in [1, 2, 3, 4]:
+        q_data = df_with_truth[df_with_truth['№ вопроса'] == q]
+        if len(q_data) > 0:
+            mae_q = mean_absolute_error(q_data['Оценка экзаменатора'], q_data['pred_score'])
+            count_q = len(q_data)
+            print(f'  Вопрос {q}: MAE = {mae_q:.3f} балла (примеров: {count_q})')
+else:
+    print('❌ Нет данных с истинными оценками для проверки')

check_quality.py

@@ -0,0 +1,57 @@
+import pandas as pd
+import numpy as np
+
+# Загрузи скачанный файл
+df = pd.read_csv('predicted_from_api.csv', sep=';')
+
+print("📊 АНАЛИЗ КАЧЕСТВА ПРЕДСКАЗАНИЙ")
+print("=" * 50)
+
+# Проверяем наличие колонок
+if 'Оценка экзаменатора' in df.columns and 'pred_score' in df.columns:
+    # Убираем строки где нет истинных оценок
+    df_clean = df.dropna(subset=['Оценка экзаменатора'])
+
+    if len(df_clean) > 0:
+        true_scores = df_clean['Оценка экзаменатора'].astype(float)
+        pred_scores = df_clean['pred_score'].astype(float)
+
+        # Основные метрики
+        mae = (abs(true_scores - pred_scores)).mean()
+        rmse = ((true_scores - pred_scores) ** 2).mean() ** 0.5
+
+        print(f"📈 Общие метрики:")
+        print(f"   MAE (средняя абсолютная ошибка): {mae:.3f}")
+        print(f"   RMSE (среднеквадратичная ошибка): {rmse:.3f}")
+        print(f"   Корреляция: {true_scores.corr(pred_scores):.3f}")
+
+        # По вопросам
+        print(f"\n📋 По типам вопросов:")
+        for q in [1, 2, 3, 4]:
+            mask = df_clean['№ вопроса'] == q
+            if mask.any():
+                q_true = true_scores[mask]
+                q_pred = pred_scores[mask]
+                q_mae = (abs(q_true - q_pred)).mean()
+
+                # Диапазон баллов для вопроса
+                if q in [1, 3]:
+                    max_score = 1
+                else:
+                    max_score = 2
+
+                print(f"   Вопрос {q} (0-{max_score}): MAE = {q_mae:.3f}, примеров = {len(q_true)}")
+
+    else:
+        print("❌ В файле нет строк с оценками экзаменатора")
+
+else:
+    print("❌ В файле отсутствуют колонки 'Оценка экзаменатора' или 'pred_score'")
+
+# Статистика предсказаний
+print(f"\n📊 Статистика предсказаний:")
+for q in [1, 2, 3, 4]:
+    mask = df['№ вопроса'] == q
+    if mask.any():
+        scores = df.loc[mask, 'pred_score'].astype(float)
+        print(f"   Вопрос {q}: ср.={scores.mean():.2f}, мин={scores.min():.2f}, макс={scores.max():.2f}")

check_small_quality.py

@@ -0,0 +1,20 @@
+import pandas as pd
+
+df = pd.read_csv('test_small.csv', sep=';')
+print("🔍 АНАЛИЗ SMALL.CSV С УЛУЧШЕННОЙ МОДЕЛЬЮ:")
+print("=" * 50)
+
+for q in [1, 4]:  # В small.csv есть только Q1 и Q4
+    q_data = df[df['№ вопроса'] == q]
+    if len(q_data) > 0:
+        scores = q_data['pred_score']
+        true_scores = q_data['Оценка экзаменатора']
+
+        print(f"📊 Вопрос {q}:")
+        print(f"   Предсказания: {scores.tolist()}")
+        print(f"   Истинные: {true_scores.tolist()}")
+
+        if len(true_scores) > 0:
+            mae = (abs(true_scores - scores)).mean()
+            print(f"   MAE: {mae:.3f}")
+        print()

create_and_analyze.py

@@ -0,0 +1,261 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+from collections import Counter
+import numpy as np
+import os
+import warnings
+
+warnings.filterwarnings('ignore')
+
+# Настройка отображения
+plt.style.use('default')
+plt.rcParams['font.family'] = 'DejaVu Sans'
+
+
+def create_test_data():
+    """Создание тестовых данных"""
+
+    test_data = """Id экзамена;Id вопроса;№ вопроса;Текст вопроса;Оценка экзаменатора;Транскрибация ответа;pred_score;объяснение_оценки
+3373871;30625752;1;"<p>Добро пожаловать на экзамен!</p>";1;"Экзаменатор: Начните диалог. Тестируемый: Здравствуйте, я хотел бы извиниться, что не смогу прийти на день рождения. Что бы вы хотели в подарок?";0.99;"🟢 Развернутый ответ | ✅ Высокое смысловое соответствие | 📊 Хорошая структура ответа | 💬 Разнообразная лексика | ⭐ Высокий балл"
+3373871;30625753;2;"<p>Расскажите о вашем жилье</p>";2;"Экзаменатор: Вы живёте в квартире или доме? Тестируемый: Я живу в квартире в центре города. Это трёхкомнатная квартира с балконом. Квартира новая, построена в 2020 году.";1.62;"🟢 Развернутый ответ | ✅ Высокое смысловое соответствие | 📊 Хорошая структура ответа | 🏠 Подробное описание | ⭐ Высокий балл"
+3373872;30625790;1;"<p>Начните диалог о работе</p>";1;"Экзаменатор: Узнайте о требованиях к работе. Тестируемый: Здравствуйте, я увидел ваше объявление о вакансии. Какие требования к соискателю? Какие документы нужны?";0.87;"🟢 Развернутый ответ | ⚠️ Умеренное смысловое соответствие | 📊 Хорошая структура ответа | 💬 Разнообразная лексика | ⭐ Высокий балл"
+3373872;30625791;2;"<p>Опишите ваше жилье</p>";1;"Экзаменатор: Расскажите о вашей квартире. Тестируемый: У меня квартира. Она хорошая. Три комнаты.";0.45;"📉 Мало предложений | ❌ Низкое смысловое соответствие | 📊 Хорошая структура ответа"
+3373873;30625828;1;"<p>Оформление документов</p>";2;"Экзаменатор: Объясните ситуацию в миграционной службе. Тестируемый: Здравствуйте, мне нужно оформить миграционную карту. Я приехал две недели назад. Можете дать мне бланк для заполнения?";1.85;"🟢 Развернутый ответ | ✅ Высокое смысловое соответствие | 📊 Хорошая структура ответа | 💬 Разнообразная лексика | ⭐ Высокий балл"
+3373873;30625829;2;"<p>Ваши любимые фильмы</p>";1;"Экзаменатор: Какие фильмы вы любите? Тестируемый: Я смотрю фантастику и детективы. Люблю новые цветные фильмы. Мой любимый фильм - Интерстеллар, он о космосе и времени.";1.15;"🟢 Развернутый ответ | ⚠️ Умеренное смысловое соответствие | 📊 Хорошая структура ответа | 💬 Разнообразная лексика"
+3373874;30625866;3;"<p>Опишите картинку</p>";2;"Экзаменатор: Что изображено на картинке? Тестируемый: На картинке изображена семья в парке. Дети играют в мяч, родители сидят на скамейке. Яркий солнечный день, лето.";1.92;"🟢 Развернутый ответ | ✅ Высокое смысловое соответствие | 🎨 Есть вступление с описанием картинки | 👤 Есть личный опыт | ⭐ Высокий балл"
+3373874;30625867;4;"<p>Расскажите о хобби</p>";1;"Экзаменатор: Чем увлекаетесь? Тестируемый: Я читаю книги. Иногда смотрю фильмы.";0.35;"📉 Мало предложений | ❌ Низкое смысловое соответствие | 📊 Хорошая структура ответа"
+3373875;30625904;1;"<p>Ситуация в больнице</p>";1;"Экзаменатор: Узнайте о приеме врача. Тестируемый: Здравствуйте, мне нужно записаться к терапевту на обследование. Когда принимает врач и какие документы нужны?";0.95;"🟢 Развернутый ответ | ✅ Высокое смысловое соответствие | 📊 Хорошая структура ответа | 💬 Разнообразная лексика | ⭐ Высокий балл"
+3373875;30625905;2;"<p>Кулинарные предпочтения</p>";2;"Экзаменатор: Какая ваша любимая кухня? Тестируемый: Я очень люблю итальянскую кухню, особенно пасту и пиццу. Также нравится японская кухня - суши и роллы. Люблю готовить сам, особенно выпечку.";1.78;"🟢 Развернутый ответ | ✅ Высокое смысловое соответствие | 📊 Хорошая структура ответа | 🏠 Подробное описание | ⭐ Высокий балл"
+"""
+
+    # Сохраняем тестовые данные в файл
+    with open('test_data.csv', 'w', encoding='utf-8') as f:
+        f.write(test_data)
+
+    print("✅ Тестовый файл 'test_data.csv' создан успешно")
+    return True
+
+
+def load_and_analyze_data():
+    """Загрузка тестовых данных"""
+
+    file_path = 'test_data.csv'
+
+    try:
+        df = pd.read_csv(file_path, encoding='utf-8', delimiter=';')
+        print("✅ Тестовый файл загружен успешно")
+    except Exception as e:
+        print(f"❌ Ошибка загрузки: {e}")
+        return None
+
+    print("=" * 60)
+    print("ТЕСТОВЫЙ АНАЛИЗ AI-ОЦЕНОК")
+    print("=" * 60)
+
+    print(f"Размер данных: {df.shape[0]} строк, {df.shape[1]} колонок")
+    print(f"Колонки: {list(df.columns)}")
+    print(f"\nПервые 3 строки:")
+    print(df.head(3))
+
+    return df
+
+
+def basic_statistics(df):
+    """Базовая статистика"""
+
+    print("\n" + "=" * 40)
+    print("БАЗОВАЯ СТАТИСТИКА")
+    print("=" * 40)
+
+    print("AI оценки (pred_score):")
+    print(f"  Среднее: {df['pred_score'].mean():.3f}")
+    print(f"  Медиана: {df['pred_score'].median():.3f}")
+    print(f"  Стандартное отклонение: {df['pred_score'].std():.3f}")
+    print(f"  Минимум: {df['pred_score'].min():.3f}")
+    print(f"  Максимум: {df['pred_score'].max():.3f}")
+
+    print("\nОценки экзаменатора:")
+    print(f"  Среднее: {df['Оценка экзаменатора'].mean():.3f}")
+    print(f"  Медиана: {df['Оценка экзаменатора'].median():.3f}")
+    print(f"  Стандартное отклонение: {df['Оценка экзаменатора'].std():.3f}")
+
+    print("\nРаспределение оценок экзаменатора:")
+    распределение = df['Оценка экзаменатора'].value_counts().sort_index()
+    for оценка, count in распределение.items():
+        print(f"  {оценка}: {count} ответов ({count / len(df) * 100:.1f}%)")
+
+
+def calculate_correlations(df):
+    """Расчет корреляций"""
+
+    print("\n" + "=" * 40)
+    print("КОРРЕЛЯЦИИ И РАСХОЖДЕНИЯ")
+    print("=" * 40)
+
+    correlation = df[['Оценка экзаменатора', 'pred_score']].corr().iloc[0, 1]
+    print(f"Корреляция между оценками: {correlation:.3f}")
+
+    df['разница'] = df['pred_score'] - df['Оценка экзаменатора']
+    df['abs_разница'] = abs(df['разница'])
+
+    print(f"Средняя абсолютная разница: {df['abs_разница'].mean():.3f}")
+    print(f"Максимальная разница: {df['abs_разница'].max():.3f}")
+    print(f"Минимальная разница: {df['abs_разница'].min():.3f}")
+
+    # Анализ согласованности
+    print("\nСОГЛАСОВАННОСТЬ ОЦЕНОК:")
+    for порог in [0.1, 0.3, 0.5, 1.0]:
+        согласованные = df[df['abs_разница'] < порог].shape[0]
+        процент = (согласованные / len(df)) * 100
+        print(f"  Разница < {порог}: {согласованные} ответов ({процент:.1f}%)")
+
+    # Направление разниц
+    завышение = len(df[df['разница'] > 0])
+    занижение = len(df[df['разница'] < 0])
+    совпадение = len(df[df['разница'] == 0])
+
+    print(f"\nНАПРАВЛЕНИЕ РАЗНИЦ:")
+    print(f"  AI завышает: {завышение} ({завышение / len(df) * 100:.1f}%)")
+    print(f"  AI занижает: {занижение} ({занижение / len(df) * 100:.1f}%)")
+    print(f"  Полное совпадение: {совпадение} ({совпадение / len(df) * 100:.1f}%)")
+
+
+def create_visualizations(df):
+    """Создание графиков"""
+
+    print("\n" + "=" * 40)
+    print("СОЗДАНИЕ ГРАФИКОВ")
+    print("=" * 40)
+
+    os.makedirs('graphs', exist_ok=True)
+
+    # 1. Scatter plot
+    plt.figure(figsize=(12, 8))
+    scatter = plt.scatter(df['Оценка экзаменатора'], df['pred_score'],
+                          c=df['abs_разница'], cmap='viridis', alpha=0.7, s=80)
+    plt.colorbar(scatter, label='Абсолютная разница')
+    plt.plot([0, 2], [0, 2], 'r--', alpha=0.5, label='Идеальное соответствие')
+    plt.xlabel('Оценка экзаменатора', fontsize=12)
+    plt.ylabel('AI оценка (pred_score)', fontsize=12)
+    plt.title('Сравнение человеческой и AI оценки\n(цвет показывает величину расхождения)', fontsize=14)
+    plt.legend()
+    plt.grid(True, alpha=0.3)
+    plt.xticks([1, 2])
+    plt.savefig('graphs/test_scatter.png', dpi=300, bbox_inches='tight')
+    plt.close()
+
+    # 2. Гистограмма разниц
+    plt.figure(figsize=(12, 6))
+    plt.hist(df['разница'], bins=15, alpha=0.7, edgecolor='black', color='skyblue')
+    plt.xlabel('Разница (AI - Человек)', fontsize=12)
+    plt.ylabel('Количество ответов', fontsize=12)
+    plt.title('Распределение разниц между AI и человеческими оценками', fontsize=14)
+    plt.grid(True, alpha=0.3)
+    plt.axvline(x=0, color='red', linestyle='--', alpha=0.8, label='Нулевая разница')
+    plt.axvline(x=df['разница'].mean(), color='orange', linestyle='--',
+                alpha=0.8, label=f'Средняя разница: {df["разница"].mean():.3f}')
+    plt.legend()
+    plt.savefig('graphs/test_histogram.png', dpi=300, bbox_inches='tight')
+    plt.close()
+
+    # 3. Box plot по вопросам
+    plt.figure(figsize=(12, 6))
+    box_data = [df[df['№ вопроса'] == question]['pred_score'].values
+                for question in sorted(df['№ вопроса'].unique())]
+
+    box_plot = plt.boxplot(box_data, labels=sorted(df['№ вопроса'].unique()),
+                           patch_artist=True)
+
+    # Раскрашиваем boxplot
+    colors = ['lightblue', 'lightgreen', 'lightcoral', 'lightyellow', 'lightpink']
+    for patch, color in zip(box_plot['boxes'], colors):
+        patch.set_facecolor(color)
+
+    plt.title('Распределение AI оценок по номерам вопросов', fontsize=14)
+    plt.xlabel('Номер вопроса', fontsize=12)
+    plt.ylabel('AI оценка (pred_score)', fontsize=12)
+    plt.grid(True, alpha=0.3)
+    plt.savefig('graphs/test_boxplot.png', dpi=300, bbox_inches='tight')
+    plt.close()
+
+    print("✅ Графики сохранены в папку 'graphs/'")
+
+
+def analyze_explanations(df):
+    """Анализ объяснений"""
+
+    print("\n" + "=" * 40)
+    print("АНАЛИЗ ОБЪЯСНЕНИЙ")
+    print("=" * 40)
+
+    все_объяснения = ' '.join(df['объяснение_оценки'].dropna().astype(str))
+    слова = [word.strip() for word in все_объяснения.split() if len(word.strip()) > 2]
+    частотность = Counter(слова)
+
+    print("Топ-10 характеристик в объяснениях:")
+    for слово, count in частотность.most_common(10):
+        print(f"  {слово}: {count}")
+
+
+def save_detailed_analysis(df):
+    """Сохранение детального анализа"""
+
+    print("\n" + "=" * 40)
+    print("СОХРАНЕНИЕ РЕЗУЛЬТАТОВ")
+    print("=" * 40)
+
+    # Создаем копию с анализом
+    df_analysis = df.copy()
+
+    # Добавляем категоризацию расхождений
+    условия = [
+        df_analysis['abs_разница'] < 0.1,
+        df_analysis['abs_разница'] < 0.3,
+        df_analysis['abs_разница'] < 0.5,
+        df_analysis['abs_разница'] >= 0.5
+    ]
+    категории = ['Отличное', 'Хорошее', 'Умеренное', 'Низкое']
+    df_analysis['качество_согласования'] = np.select(условия, категории, default='Низкое')
+
+    # Сортируем по наибольшим расхождениям
+    df_analysis = df_analysis.sort_values('abs_разница', ascending=False)
+
+    try:
+        # Сохраняем в Excel
+        with pd.ExcelWriter('detailed_analysis.xlsx', engine='openpyxl') as writer:
+            df_analysis.to_excel(writer, sheet_name='Все_данные_с_анализом', index=False)
+        print("✅ Детальный анализ сохранен в 'detailed_analysis.xlsx'")
+    except Exception as e:
+        print(f"⚠️ Не удалось сохранить Excel: {e}")
+
+
+def main():
+    """Основная функция"""
+
+    print("Создание тестовых данных...")
+    if not create_test_data():
+        return
+
+    df = load_and_analyze_data()
+    if df is None:
+        return
+
+    basic_statistics(df)
+    calculate_correlations(df)
+    create_visualizations(df)
+    analyze_explanations(df)
+    save_detailed_analysis(df)
+
+    print("\n" + "=" * 60)
+    print("✅ ТЕСТОВЫЙ АНАЛИЗ ЗАВЕРШЕН!")
+    print("=" * 60)
+    print("📊 Созданные файлы:")
+    print("   • test_data.csv - тестовые данные")
+    print("   • graphs/test_scatter.png - сравнение оценок")
+    print("   • graphs/test_histogram.png - распределение разниц")
+    print("   • graphs/test_boxplot.png - оценки по вопросам")
+    print("   • detailed_analysis.xlsx - детальный отчет")
+
+
+if __name__ == "__main__":
+    main()

deploy-to-yandex.ps1.py

@@ -0,0 +1,30 @@
+# deploy-to-yandex.ps1
+Write-Host "🚀 Начало развертывания в Yandex Cloud..." -ForegroundColor Green
+
+# Переменные (ЗАМЕНИТЕ на свои!)
+$REGISTRY_ID = "your-registry-id"  # Найти в консоли: Container Registry -> ID реестра
+$IMAGE_NAME = "exam-scorer"
+$TAG = "latest"
+$FULL_IMAGE = "cr.yandex/$REGISTRY_ID/$IMAGE_NAME`:$TAG"
+
+# 1. Сборка Docker образа
+Write-Host "📦 Сборка Docker образа..." -ForegroundColor Yellow
+docker build -t $FULL_IMAGE .
+
+# 2. Авторизация в Yandex Container Registry
+Write-Host "🔐 Авторизация в Container Registry..." -ForegroundColor Yellow
+yc container registry configure-docker
+
+# 3. Загрузка образа в реестр
+Write-Host "⬆️ Загрузка образа в Yandex Cloud..." -ForegroundColor Yellow
+docker push $FULL_IMAGE
+
+Write-Host "✅ Образ успешно загружен: $FULL_IMAGE" -ForegroundColor Green
+Write-Host ""
+Write-Host "🎯 Дальнейшие действия:" -ForegroundColor Cyan
+Write-Host "1. В консоли Yandex Cloud перейдите в 'Serverless Containers'"
+Write-Host "2. Создайте новый контейнер"
+Write-Host "3. Укажите образ: $FULL_IMAGE"
+Write-Host "4. Настройте порт: 8000"
+Write-Host "5. Задайте переменные окружения:"
+Write-Host "   - PYTHONPATH=/app"

deploy-to-yandex.sh.py

@@ -0,0 +1,32 @@
+#!/bin/bash
+set -e
+
+echo "🚀 Начало развертывания в Yandex Cloud..."
+
+# Переменные (замените на свои)
+REGISTRY_ID="your-registry-id"  # Найти в консоли: Container Registry -> ID реестра
+IMAGE_NAME="exam-scorer"
+TAG="latest"
+FULL_IMAGE="cr.yandex/${REGISTRY_ID}/${IMAGE_NAME}:${TAG}"
+
+# 1. Сборка Docker образа
+echo "📦 Сборка Docker образа..."
+docker build -t ${FULL_IMAGE} .
+
+# 2. Авторизация в Yandex Container Registry
+echo "🔐 Авторизация в Container Registry..."
+yc container registry configure-docker
+
+# 3. Загрузка образа в реестр
+echo "⬆️ Загрузка образа в Yandex Cloud..."
+docker push ${FULL_IMAGE}
+
+echo "✅ Образ успешно загружен: ${FULL_IMAGE}"
+echo ""
+echo "🎯 Дальнейшие действия:"
+echo "1. В консоли Yandex Cloud перейдите в 'Serverless Containers'"
+echo "2. Создайте новый контейнер"
+echo "3. Укажите образ: ${FULL_IMAGE}"
+echo "4. Настройте порт: 8000"
+echo "5. Задайте переменные окружения:"
+echo "   - PYTHONPATH=/app"

evaluate_mae.py

@@ -0,0 +1,63 @@
+import argparse
+import pandas as pd
+import numpy as np
+import sys
+
+def safe_float(s):
+    try:
+        return float(s)
+    except Exception:
+        return np.nan
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--pred", required=True)
+    ap.add_argument("--gold", required=True)
+    ap.add_argument("--pred-col", default="predicted_score")
+    ap.add_argument("--score-col", default="examiner_score")
+    ap.add_argument("--question-col", default="question_number")
+    ap.add_argument("--key", default="")
+    args = ap.parse_args()
+
+    p = pd.read_csv(args.pred)
+    g = pd.read_csv(args.gold)
+
+    if args.pred_col not in p.columns:
+        print(f"ERROR: нет {args.pred_col} в {args.pred}"); sys.exit(1)
+    if args.score_col not in g.columns:
+        print(f"ERROR: нет {args.score_col} в {args.gold}"); sys.exit(1)
+
+    keys = [k.strip() for k in args.key.split(",") if k.strip()]
+    if keys:
+        for miss in [k for k in keys if k not in p.columns]:
+            print(f"ERROR: нет ключа {miss} в pred"); sys.exit(1)
+        for miss in [k for k in keys if k not in g.columns]:
+            print(f"ERROR: нет ключа {miss} в gold"); sys.exit(1)
+        merged = p[keys + [args.pred_col]].merge(
+            g[keys + [args.score_col]], on=keys, how="inner", validate="one_to_one"
+        )
+    else:
+        if len(p) != len(g):
+            print("ERROR: разные размеры pred/gold и нет ключа --key"); sys.exit(1)
+        merged = pd.DataFrame({
+            args.pred_col: p[args.pred_col].values,
+            args.score_col: g[args.score_col].values
+        })
+
+    y_pred = merged[args.pred_col].map(safe_float)
+    y_true = merged[args.score_col].map(safe_float)
+    mask = (~y_pred.isna()) & (~y_true.isna())
+    mae = np.mean(np.abs(y_pred[mask] - y_true[mask]))
+    print(f"MAE (общий): {mae:.4f} | N={mask.sum()}")
+
+    # по вопросам, если есть
+    try:
+        qp = p.loc[mask, args.question_col] if args.question_col in p.columns else g.loc[mask, args.question_col]
+        df = pd.DataFrame({"qn": qp.values, "pred": y_pred[mask].values, "true": y_true[mask].values})
+        for q, v in df.groupby("qn").apply(lambda d: np.mean(np.abs(d["pred"] - d["true"]))).sort_index().items():
+            print(f"  Q{int(q)} MAE: {v:.4f}")
+    except Exception:
+        pass
+
+if __name__ == "__main__":
+    main()

feature_engineering.py

@@ -0,0 +1,217 @@
+# feature_engineering.py
+from __future__ import annotations
+
+import re
+from typing import Iterable, List, Tuple, Optional
+
+import numpy as np
+import pandas as pd
+
+try:
+    from sentence_transformers import SentenceTransformer, util as sbert_util
+except Exception:  # чтобы не падать на установке
+    SentenceTransformer = None  # type: ignore
+    sbert_util = None  # type: ignore
+
+try:
+    import language_tool_python
+except Exception:
+    language_tool_python = None  # type: ignore
+
+
+_HTML_TAG_RE = re.compile(r"<[^>]+>")
+_WS_RE = re.compile(r"\s+")
+_PUNCT_RE = re.compile(r"[^\w\s?!.,:;ёЁа-яА-Я-]", re.UNICODE)
+
+# мини-лексиконы под критерии
+POLITE_WORDS = {"здравствуйте", "здравствуй", "пожалуйста", "спасибо", "будьте добры"}
+APOLOGY_WORDS = {"извините", "простите", "прошу прощения"}
+FAMILY_WORDS = {"семья", "сын", "дочь", "дети", "ребёнок", "муж", "жена", "родители"}
+SEASON_WORDS = {"зима", "весна", "лето", "осень"}
+SHOP_WORDS = {"рассрочка", "гарантия", "характеристики", "документы", "касса"}
+YESNO_WORDS = {"да", "нет", "наверное", "возможно"}
+
+
+def _strip_html(s: str) -> str:
+    s = _HTML_TAG_RE.sub(" ", s)
+    s = _WS_RE.sub(" ", s).strip()
+    return s
+
+
+def _only_text(s: str) -> str:
+    s = s.lower()
+    s = _strip_html(s)
+    s = _PUNCT_RE.sub(" ", s)
+    s = _WS_RE.sub(" ", s).strip()
+    return s
+
+
+def _split_sentences(s: str) -> List[str]:
+    # простая сегментация
+    parts = re.split(r"(?<=[.!?])\s+", s)
+    return [p.strip() for p in parts if p.strip()]
+
+
+def _strip_examiner_lines(text: str) -> str:
+    """
+    Убираем вероятные реплики экзаменатора: предложения с '?',
+    короткие управляющие фразы ("хорошо.", "итак, ...").
+    """
+    sents = _split_sentences(text)
+    kept = []
+    for i, sent in enumerate(sents):
+        low = sent.lower()
+        if "?" in sent:
+            continue
+        if low in {"хорошо.", "отлично.", "прекрасно.", "молодец."}:
+            continue
+        if low.startswith(("итак", "следующий", "теперь", "будьте", "ответьте")) and "?" in low:
+            continue
+        kept.append(sent)
+    return " ".join(kept) if kept else text
+
+
+def _count_matches(words: Iterable[str], tokens: Iterable[str]) -> int:
+    wset = set(w.lower() for w in words)
+    return sum(1 for t in tokens if t in wset)
+
+
+class FeatureExtractor:
+    """
+    Лёгкий экстрактор признаков:
+    - очистка текста/HTML
+    - отделение реплик экзаменатора (эвристика)
+    - семантическая близость (SBERT)
+    - длины, кол-во предложений, вопросительных/восклицательных и пр.
+    - индикаторы по заданиям (вежливость, извинение, семья, рассрочка, …)
+    - (опц.) grammar_error_count через LanguageTool
+    """
+
+    def __init__(
+        self,
+        sbert_model_name: str = "cointegrated/rubert-tiny",
+        use_grammar: bool = False,
+        strip_examiner: bool = True,
+    ) -> None:
+        self.strip_examiner = strip_examiner
+
+        # SBERT
+        self.sbert: Optional[SentenceTransformer]
+        if SentenceTransformer is None:
+            self.sbert = None
+        else:
+            self.sbert = SentenceTransformer(sbert_model_name)
+
+        # Grammar
+        self.grammar = None
+        if use_grammar and language_tool_python is not None:
+            try:
+                self.grammar = language_tool_python.LanguageTool("ru")
+            except Exception:
+                self.grammar = None  # безопасно отключаем
+
+    # --------- примитивные фичи ----------
+    def _basic_text_stats(self, text: str) -> Tuple[int, int, int, int, int, float]:
+        cleaned = _only_text(text)
+        tokens = cleaned.split()
+        sents = _split_sentences(text)
+        qmarks = text.count("?")
+        emarks = text.count("!")
+        avg_sent_len = (len(tokens) / max(len(sents), 1)) if tokens else 0.0
+        return len(tokens), len(sents), qmarks, emarks, len(set(tokens)), float(avg_sent_len)
+
+    def _semantic_sim(self, q: str, a: str) -> float:
+        if not self.sbert or sbert_util is None:
+            return 0.0
+        try:
+            emb_q = self.sbert.encode([q], convert_to_tensor=True, normalize_embeddings=True)
+            emb_a = self.sbert.encode([a], convert_to_tensor=True, normalize_embeddings=True)
+            sim = float(sbert_util.cos_sim(emb_q, emb_a)[0][0].cpu().item())
+            # нормализуем к [0..1] прим��рно
+            return max(0.0, min(1.0, (sim + 1.0) / 2.0))
+        except Exception:
+            return 0.0
+
+    def _grammar_errors(self, text: str) -> int:
+        if not self.grammar:
+            return 0
+        try:
+            matches = self.grammar.check(text)
+            return len(matches)
+        except Exception:
+            return 0
+
+    # --------- фичи под задания ----------
+    def _question_specific_flags(self, qnum: int, answer_text: str, question_text: str) -> dict:
+        a_clean = _only_text(answer_text)
+        a_tokens = a_clean.split()
+
+        flags = {
+            "has_politeness": int(_count_matches(POLITE_WORDS, a_tokens) > 0),
+            "has_apology": int(_count_matches(APOLOGY_WORDS, a_tokens) > 0),
+            "has_yesno": int(_count_matches(YESNO_WORDS, a_tokens) > 0),
+            "mentions_family": int(_count_matches(FAMILY_WORDS, a_tokens) > 0),
+            "mentions_season": int(_count_matches(SEASON_WORDS, a_tokens) > 0),
+            "mentions_shop": int(_count_matches(SHOP_WORDS, a_tokens) > 0),
+            "has_question_mark": int("?" in answer_text),
+        }
+
+        # лёгкие правила по задачам
+        if qnum == 1:  # извиниться + спросить
+            flags["task_completed_like_q1"] = int(flags["has_apology"] and flags["has_question_mark"])
+        elif qnum == 2:  # диалоговые ответы
+            flags["task_completed_like_q2"] = int(flags["has_yesno"] or len(a_tokens) > 12)
+        elif qnum == 3:  # магазин: документы/рассрочка/характеристики
+            flags["task_completed_like_q3"] = int(flags["mentions_shop"] or len(a_tokens) > 25)
+        elif qnum == 4:  # описание картинки + семья/дети
+            flags["task_completed_like_q4"] = int(flags["mentions_family"] or flags["mentions_season"])
+        else:
+            flags["task_completed_like_q1"] = 0
+
+        # семантика вопрос-ответ
+        flags["qa_semantic_sim"] = self._semantic_sim(question_text, answer_text)
+        return flags
+
+    # --------- публичное API ----------
+    def extract_row_features(self, row: pd.Series) -> dict:
+        qnum = int(row.get("№ вопроса") or row.get("question_number") or 0)
+        qtext_raw = str(row.get("Текст вопроса") or row.get("question_text") or "")
+        atext_raw = str(row.get("Транскрибация") or row.get("transcript") or row.get("answer_text") or "")
+
+        qtext = _strip_html(qtext_raw)
+        atext = _strip_html(atext_raw)
+        if self.strip_examiner:
+            atext = _strip_examiner_lines(atext)
+
+        tok_len, sent_cnt, qmarks, emarks, uniq, avg_sent = self._basic_text_stats(atext)
+        grams = self._grammar_errors(atext)
+
+        base = {
+            "question_number": qnum,
+            "question_text": qtext,
+            "answer_text": atext,
+            "tokens_len": tok_len,
+            "sent_count": sent_cnt,
+            "q_mark_count": qmarks,
+            "excl_mark_count": emarks,
+            "uniq_tokens": uniq,
+            "avg_sent_len": avg_sent,
+            "grammar_errors": grams,
+            "answer_len_chars": len(atext),
+        }
+        base.update(self._question_specific_flags(qnum, atext, qtext))
+        return base
+
+    def extract_all_features(self, df: pd.DataFrame) -> pd.DataFrame:
+        feats = [self.extract_row_features(r) for _, r in df.iterrows()]
+        out = pd.DataFrame(feats)
+
+        # защитимся от NaN и типов
+        num_cols = [c for c in out.columns if c not in {"question_text", "answer_text"}]
+        for c in num_cols:
+            if c not in {"question_text", "answer_text"}:
+                out[c] = pd.to_numeric(out[c], errors="coerce")
+        out = out.fillna(
+            {c: 0 for c in out.columns if c not in {"question_text", "answer_text"}}
+        )
+        return out

feature_extractor.py

@@ -0,0 +1,368 @@
+import pandas as pd
+import numpy as np
+import re
+from typing import Dict, List, Tuple, Optional
+import warnings
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+
+warnings.filterwarnings('ignore')
+
+
+class RussianFeatureExtractor:
+    """Исправленная версия экстрактора признаков с работающим composite_quality_score"""
+
+    def __init__(self, use_heavy_models: bool = False):
+        print("Инициализация исправленного экстрактора признаков...")
+
+        self.use_heavy_models = use_heavy_models
+        self.sbert_model = None
+
+        # Инициализация моделей
+        self._initialize_models()
+
+        # Списки ключевых слов
+        self.greeting_words = ['здравствуйте', 'привет', 'добрый', 'здравствуй', 'доброе', 'приветствую']
+        self.question_words = ['как', 'что', 'где', 'когда', 'почему', 'можно', 'сколько', 'какой', 'какая']
+        self.descriptive_words = ['вижу', 'изображен', 'находится', 'делает', 'одет', 'стоит', 'сидит']
+        self.connector_words = ['потому что', 'поэтому', 'так как', 'например', 'кроме того']
+        self.emotional_words = ['красиво', 'интересно', 'замечательно', 'прекрасно', 'нравится']
+        self.spatial_words = ['слева', 'справа', 'вверху', 'внизу', 'рядом', 'около']
+
+        print("✅ Инициализация завершена!")
+
+    def _initialize_models(self):
+        """Инициализация моделей"""
+        if self.use_heavy_models:
+            print("ℹ️ Тяжелые модели отключены для стабильности")
+        print("ℹ️ Используем легкие методы (TF-IDF)")
+
+    def clean_text(self, text: str) -> str:
+        """Очистка текста"""
+        if pd.isna(text):
+            return ""
+        text = str(text)
+        text = re.sub(r'<[^>]+>', '', text)
+        text = re.sub(r'[^\w\sа-яА-ЯёЁ.,!?;:()-]', '', text)
+        text = re.sub(r'\s+', ' ', text).strip()
+        return text
+
+    def extract_basic_features(self, text: str) -> Dict[str, float]:
+        """Базовые текстовые признаки"""
+        text_clean = self.clean_text(text)
+
+        if not text_clean:
+            return {
+                'text_length': 0, 'word_count': 0, 'sentence_count': 0,
+                'avg_word_length': 0, 'lexical_diversity': 0,
+                'has_questions': 0, 'has_exclamations': 0
+            }
+
+        # Базовые метрики
+        words = re.findall(r'\b[а-яёa-z]+\b', text_clean.lower())
+        sentences = [s.strip() for s in re.split(r'[.!?]+', text_clean) if s.strip()]
+
+        word_count = len(words)
+        text_length = len(text_clean)
+        sentence_count = len(sentences)
+
+        features = {
+            'text_length': text_length,
+            'word_count': word_count,
+            'sentence_count': sentence_count,
+            'avg_word_length': sum(len(w) for w in words) / max(word_count, 1),
+            'lexical_diversity': len(set(words)) / max(word_count, 1),
+            'has_questions': int('?' in text_clean),
+            'has_exclamations': int('!' in text_clean),
+        }
+
+        return features
+
+    def extract_semantic_features(self, question: str, answer: str) -> Dict[str, float]:
+        """Семантические признаки"""
+        question_clean = self.clean_text(question)
+        answer_clean = self.clean_text(answer)
+
+        features = {
+            'keyword_overlap': 0.0,
+            'response_relevance': 0.0
+        }
+
+        if not answer_clean or not question_clean:
+            return features
+
+        try:
+            # Упрощенный анализ ключевых слов
+            question_words = set(re.findall(r'\b[а-яё]+\b', question_clean.lower()))
+            answer_words = set(re.findall(r'\b[а-яё]+\b', answer_clean.lower()))
+
+            if question_words:
+                common_words = question_words.intersection(answer_words)
+                features['keyword_overlap'] = len(common_words) / max(len(question_words), 1)
+                features['response_relevance'] = min(1.0, len(answer_words) / max(len(question_words), 1))
+
+        except Exception as e:
+            print(f"Ошибка семантических признаков: {e}")
+
+        return features
+
+    def extract_grammar_features(self, text: str) -> Dict[str, float]:
+        """Грамматические признаки"""
+        text_clean = self.clean_text(text)
+
+        features = {
+            'grammar_quality': 0.5,  # Базовая оценка
+            'has_punctuation': 0.0,
+            'sentence_completeness': 0.0
+        }
+
+        if not text_clean:
+            return features
+
+        sentences = [s.strip() for s in re.split(r'[.!?]+', text_clean) if s.strip()]
+        words = text_clean.split()
+
+        if sentences:
+            # Проверка пунктуации
+            features['has_punctuation'] = 1.0 if any(mark in text_clean for mark in '.!?') else 0.0
+
+            # Полнота предложений
+            complete_sentences = sum(1 for s in sentences if len(s.split()) >= 3)
+            features['sentence_completeness'] = complete_sentences / max(len(sentences), 1)
+
+            # Улучшенная эвристика грамматического качества
+            grammar_score = 0.0
+            grammar_score += features['has_punctuation'] * 0.3
+            grammar_score += features['sentence_completeness'] * 0.4
+
+            # Дополнительные эвристики
+            if len(words) > 5:
+                avg_sentence_len = len(words) / len(sentences)
+                if 5 <= avg_sentence_len <= 20:
+                    grammar_score += 0.2
+                elif avg_sentence_len > 20:
+                    grammar_score += 0.1
+
+            features['grammar_quality'] = min(1.0, grammar_score)
+
+        return features
+
+    def extract_style_features(self, text: str) -> Dict[str, float]:
+        """Стилистические признаки"""
+        text_clean = self.clean_text(text).lower()
+
+        features = {
+            'has_greeting': 0.0,
+            'has_description': 0.0,
+            'has_connectors': 0.0,
+            'has_emotional_words': 0.0,
+            'style_score': 0.0
+        }
+
+        if not text_clean:
+            return features
+
+        # Стилистические маркеры
+        features.update({
+            'has_greeting': float(any(greet in text_clean for greet in self.greeting_words)),
+            'has_description': float(any(desc in text_clean for desc in self.descriptive_words)),
+            'has_connectors': float(any(conn in text_clean for conn in self.connector_words)),
+            'has_emotional_words': float(any(emot in text_clean for emot in self.emotional_words)),
+        })
+
+        # Оценка стиля
+        style_indicators = sum([
+            features['has_greeting'],
+            features['has_connectors'],
+            features['has_emotional_words']
+        ])
+        features['style_score'] = min(1.0, style_indicators / 3)
+
+        return features
+
+    def extract_quality_features(self, text: str, question_type: int) -> Dict[str, float]:
+        """Признаки качества ответа"""
+        text_clean = self.clean_text(text)
+        words = text_clean.split()
+        word_count = len(words)
+
+        features = {
+            'answer_length_sufficiency': min(1.0, word_count / 30),  # Нормализованная длина
+            'content_richness': 0.0,
+            'engagement_level': 0.0
+        }
+
+        if not text_clean:
+            return features
+
+        # Богатство контента (лексическое разнообразие + длина)
+        lexical_diversity = len(set(words)) / max(word_count, 1)
+        features['content_richness'] = min(1.0, (lexical_diversity + features['answer_length_sufficiency']) / 2)
+
+        # Уровень вовлеченности
+        engagement = 0.0
+        engagement += features['answer_length_sufficiency'] * 0.4
+        engagement += lexical_diversity * 0.3
+        engagement += (1.0 if '?' in text_clean else 0.0) * 0.3
+        features['engagement_level'] = engagement
+
+        return features
+
+    def extract_all_features(self, row: pd.Series) -> Dict[str, float]:
+        """Извлечение всех признаков - ИСПРАВЛЕННАЯ ВЕРСИЯ"""
+        try:
+            # Безопасное извлечение данных
+            question = row.get('Текст вопроса', row.get('Вопрос', ''))
+            answer = row.get('Транскрибация ответа', row.get('Транскрипт', row.get('Ответ', '')))
+            question_type = row.get('№ вопроса', row.get('Тип вопроса', 1))
+
+            try:
+                question_type = int(question_type)
+            except:
+                question_type = 1
+
+            features = {}
+
+            # 1. Базовые признаки (надежные)
+            basic_features = self.extract_basic_features(answer)
+            features.update(basic_features)
+
+            # 2. Семантические признаки
+            semantic_features = self.extract_semantic_features(question, answer)
+            features.update(semantic_features)
+
+            # 3. Грамматические признаки
+            grammar_features = self.extract_grammar_features(answer)
+            features.update(grammar_features)
+
+            # 4. Стилистические признаки
+            style_features = self.extract_style_features(answer)
+            features.update(style_features)
+
+            # 5. Признаки качества
+            quality_features = self.extract_quality_features(answer, question_type)
+            features.update(quality_features)
+
+            # 6. Тип вопроса
+            features['question_type'] = float(question_type)
+
+            # 7. ИСПРАВЛЕННЫЙ композитный показатель
+            features['composite_quality_score'] = self._calculate_quality_score(features)
+
+            return features
+
+        except Exception as e:
+            print(f"❌ Ошибка при извлечении признаков: {e}")
+            # Возвращаем базовые признаки
+            return self._get_fallback_features()
+
+    def _calculate_quality_score(self, features: Dict[str, float]) -> float:
+        """ИСПРАВЛЕННЫЙ расчет качества ответа"""
+
+        # Веса для разных категорий
+        weights = {
+            # Семантика и релевантность (35%)
+            'keyword_overlap': 0.20,
+            'response_relevance': 0.15,
+
+            # Грамматика и структура (25%)
+            'grammar_quality': 0.15,
+            'sentence_completeness': 0.10,
+
+            # Стиль и вовлеченность (25%)
+            'style_score': 0.10,
+            'engagement_level': 0.15,
+
+            # Содержание (15%)
+            'content_richness': 0.15
+        }
+
+        total_score = 0.0
+        total_weight = 0.0
+
+        for feature, weight in weights.items():
+            if feature in features:
+                value = features[feature]
+                total_score += value * weight
+                total_weight += weight
+
+        # Нормализация на случай отсутствующих признаков
+        if total_weight > 0:
+            final_score = total_score / total_weight
+        else:
+            final_score = 0.5  # нейтральная оценка
+
+        return min(1.0, max(0.0, final_score))
+
+    def _get_fallback_features(self) -> Dict[str, float]:
+        """Базовые признаки при ошибке"""
+        return {
+            'text_length': 0, 'word_count': 0, 'sentence_count': 0,
+            'avg_word_length': 0, 'lexical_diversity': 0,
+            'has_questions': 0, 'has_exclamations': 0,
+            'keyword_overlap': 0, 'response_relevance': 0,
+            'grammar_quality': 0.5, 'has_punctuation': 0, 'sentence_completeness': 0,
+            'has_greeting': 0, 'has_description': 0, 'has_connectors': 0,
+            'has_emotional_words': 0, 'style_score': 0,
+            'answer_length_sufficiency': 0, 'content_richness': 0, 'engagement_level': 0,
+            'question_type': 1, 'composite_quality_score': 0.5
+        }
+
+    def extract_features_for_dataframe(self, df: pd.DataFrame, sample_size: int = None) -> pd.DataFrame:
+        """Извлечение признаков для датафрейма"""
+        if sample_size and sample_size < len(df):
+            df = df.sample(sample_size, random_state=42)
+            print(f"Взята выборка: {len(df)} строк")
+
+        print(f"Извлечение признаков для {len(df)} строк...")
+        features_list = []
+        successful = 0
+
+        for idx, row in df.iterrows():
+            if idx % 50 == 0 and idx > 0:
+                print(f"Обработано {idx}/{len(df)} строк...")
+
+            try:
+                features = self.extract_all_features(row)
+                features['original_index'] = idx
+                features_list.append(features)
+                successful += 1
+            except Exception as e:
+                print(f"❌ Ошибка в строке {idx}: {e}")
+                continue
+
+        if features_list:
+            features_df = pd.DataFrame(features_list)
+            features_df.set_index('original_index', inplace=True)
+
+            success_rate = successful / len(df)
+            print(f"✅ Извлечение завершено! Успешно: {successful}/{len(df)} ({success_rate:.1%})")
+
+            return features_df
+        else:
+            print("❌ Не удалось извлечь признаки")
+            return pd.DataFrame()
+
+
+# Быстрая функция для тестирования
+def extract_quick_features(text: str) -> Dict[str, float]:
+    extractor = RussianFeatureExtractor()
+    return extractor.extract_basic_features(text)
+
+
+if __name__ == "__main__":
+    # Тест исправленной версии
+    extractor = RussianFeatureExtractor()
+    test_data = {
+        'Текст вопроса': ['Расскажите о вашем городе'],
+        'Транскрибация ответа': ['Привет! Я живу в Москве. Это большой и красивый город с множеством парков и музеев.'],
+        '№ вопроса': [1]
+    }
+    test_df = pd.DataFrame(test_data)
+    features = extractor.extract_all_features(test_df.iloc[0])
+
+    print("🎯 ТЕСТ ИСПРАВЛЕННОЙ ВЕРСИИ:")
+    print(f"Композитный показатель: {features['composite_quality_score']:.3f}")
+    print(f"Грамматическое качество: {features['grammar_quality']:.3f}")
+    print(f"Стилевой показатель: {features['style_score']:.3f}")
+    print(f"Количество слов: {features['word_count']}")

features_description.txt

@@ -0,0 +1,111 @@
+ОПИСАНИЕ ПРИЗНАКОВ:
+==================
+
+text_length:
+  Тип: int64
+  Не-NULL: 100
+  Среднее: 1246.900
+  Корреляция с оценкой: 0.442
+
+word_count:
+  Тип: int64
+  Не-NULL: 100
+  Среднее: 195.060
+  Корреляция с оценкой: 0.447
+
+sentence_count:
+  Тип: int64
+  Не-NULL: 100
+  Среднее: 33.830
+  Корреляция с оценкой: 0.365
+
+avg_word_length:
+  Тип: float64
+  Не-NULL: 100
+  Среднее: 6.497
+  Корреляция с оценкой: -0.259
+
+lexical_diversity:
+  Тип: float64
+  Не-NULL: 100
+  Среднее: 0.763
+  Корреляция с оценкой: -0.336
+
+semantic_similarity:
+  Тип: float64
+  Не-NULL: 100
+  Среднее: 0.000
+  Корреляция с оценкой: nan
+
+keyword_overlap:
+  Тип: float64
+  Не-NULL: 100
+  Среднее: 0.000
+  Корреляция с оценкой: nan
+
+grammar_error_count:
+  Тип: int64
+  Не-NULL: 100
+  Среднее: 0.000
+  Корреляция с оценкой: nan
+
+grammar_error_ratio:
+  Тип: int64
+  Не-NULL: 100
+  Среднее: 0.000
+  Корреляция с оценкой: nan
+
+has_punctuation:
+  Тип: float64
+  Не-NULL: 100
+  Среднее: 0.000
+  Корреляция с оценкой: nan
+
+has_greeting:
+  Тип: float64
+  Не-NULL: 100
+  Среднее: 0.470
+  Корреляция с оценкой: -0.342
+
+has_questions:
+  Тип: float64
+  Не-NULL: 100
+  Среднее: 0.920
+  Корреляция с оценкой: 0.179
+
+has_description:
+  Тип: float64
+  Не-NULL: 100
+  Среднее: 0.310
+  Корреляция с оценкой: 0.226
+
+dialog_initiation:
+  Тип: float64
+  Не-NULL: 25
+  Среднее: 0.968
+  Корреляция с оценкой: 0.363
+
+question_type:
+  Тип: float64
+  Не-NULL: 100
+  Среднее: 2.500
+  Корреляция с оценкой: 0.146
+
+response_adequacy:
+  Тип: float64
+  Не-NULL: 25
+  Среднее: 0.970
+  Корреляция с оценкой: 0.327
+
+information_seeking:
+  Тип: float64
+  Не-NULL: 25
+  Среднее: 0.920
+  Корреляция с оценкой: -0.147
+
+descriptive_detail:
+  Тип: float64
+  Не-NULL: 25
+  Среднее: 1.000
+  Корреляция с оценкой: nan
+

features_description_detailed.txt

@@ -0,0 +1,179 @@
+ПОДРОБНОЕ ОПИСАНИЕ ПРИЗНАКОВ
+==================================================
+
+text_length:
+  Тип: int64
+  Не-NULL: 50
+  Среднее: 1676.120
+  Std: 1190.330
+  Min: 328.000
+  Max: 5002.000
+
+word_count:
+  Тип: int64
+  Не-NULL: 50
+  Среднее: 265.600
+  Std: 196.751
+  Min: 46.000
+  Max: 820.000
+
+sentence_count:
+  Тип: int64
+  Не-NULL: 50
+  Среднее: 47.720
+  Std: 39.596
+  Min: 1.000
+  Max: 157.000
+
+avg_word_length:
+  Тип: float64
+  Не-NULL: 50
+  Среднее: 5.156
+  Std: 0.386
+  Min: 4.443
+  Max: 6.397
+
+lexical_diversity:
+  Тип: float64
+  Не-NULL: 50
+  Среднее: 0.618
+  Std: 0.087
+  Min: 0.431
+  Max: 0.744
+
+has_questions:
+  Тип: int64
+  Не-NULL: 50
+  Среднее: 0.920
+  Std: 0.274
+  Min: 0.000
+  Max: 1.000
+
+has_exclamations:
+  Тип: int64
+  Не-NULL: 50
+  Среднее: 0.000
+  Std: 0.000
+  Min: 0.000
+  Max: 0.000
+
+keyword_overlap:
+  Тип: float64
+  Не-NULL: 50
+  Среднее: 0.768
+  Std: 0.078
+  Min: 0.593
+  Max: 0.902
+
+response_relevance:
+  Тип: float64
+  Не-NULL: 50
+  Среднее: 1.000
+  Std: 0.000
+  Min: 1.000
+  Max: 1.000
+
+grammar_quality:
+  Тип: float64
+  Не-NULL: 50
+  Среднее: 0.682
+  Std: 0.146
+  Min: 0.419
+  Max: 0.868
+
+has_punctuation:
+  Тип: float64
+  Не-NULL: 50
+  Среднее: 0.940
+  Std: 0.240
+  Min: 0.000
+  Max: 1.000
+
+sentence_completeness:
+  Тип: float64
+  Не-NULL: 50
+  Среднее: 0.724
+  Std: 0.157
+  Min: 0.297
+  Max: 1.000
+
+has_greeting:
+  Тип: float64
+  Не-NULL: 50
+  Среднее: 0.540
+  Std: 0.503
+  Min: 0.000
+  Max: 1.000
+
+has_description:
+  Тип: float64
+  Не-NULL: 50
+  Среднее: 0.540
+  Std: 0.503
+  Min: 0.000
+  Max: 1.000
+
+has_connectors:
+  Тип: float64
+  Не-NULL: 50
+  Среднее: 0.500
+  Std: 0.505
+  Min: 0.000
+  Max: 1.000
+
+has_emotional_words:
+  Тип: float64
+  Не-NULL: 50
+  Среднее: 0.360
+  Std: 0.485
+  Min: 0.000
+  Max: 1.000
+
+style_score:
+  Тип: float64
+  Не-NULL: 50
+  Среднее: 0.467
+  Std: 0.213
+  Min: 0.000
+  Max: 1.000
+
+answer_length_sufficiency:
+  Тип: float64
+  Не-NULL: 50
+  Среднее: 1.000
+  Std: 0.000
+  Min: 1.000
+  Max: 1.000
+
+content_richness:
+  Тип: float64
+  Не-NULL: 50
+  Среднее: 0.861
+  Std: 0.038
+  Min: 0.745
+  Max: 0.929
+
+engagement_level:
+  Тип: float64
+  Не-NULL: 50
+  Среднее: 0.892
+  Std: 0.090
+  Min: 0.576
+  Max: 0.958
+
+question_type:
+  Тип: float64
+  Не-NULL: 50
+  Среднее: 2.460
+  Std: 1.129
+  Min: 1.000
+  Max: 4.000
+
+composite_quality_score:
+  Тип: float64
+  Не-NULL: 50
+  Среднее: 0.788
+  Std: 0.054
+  Min: 0.659
+  Max: 0.894
+

minimal_app.py

@@ -0,0 +1,40 @@
+import streamlit as st
+import subprocess
+import sys
+
+
+def install_package(package):
+    subprocess.check_call([sys.executable, "-m", "pip", "install", package])
+
+
+try:
+    from transformers import pipeline
+except ImportError:
+    st.warning("Устанавливаем transformers...")
+    install_package("transformers")
+    from transformers import pipeline
+
+st.title("Минимальное приложение с Hugging Face")
+
+
+# Простая модель для теста
+@st.cache_resource
+def load_model():
+    try:
+        return pipeline("sentiment-analysis")
+    except Exception as e:
+        st.error(f"Ошибка загрузки модели: {e}")
+        return None
+
+
+model = load_model()
+
+if model:
+    text = st.text_input("Введите текст:", "I love this!")
+
+    if st.button("Анализировать") and text:
+        result = model(text)[0]
+        st.write(f"Результат: {result['label']}")
+        st.write(f"Уверенность: {result['score']:.4f}")
+else:
+    st.error("Не удалось загрузить модель")

models/catboost_Q1.cbm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7756476f07583a1134762daef9296d39f6b89c7fac6200a342c3cd1dcabd5a98
+size 2223544

models/catboost_Q2.cbm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:384cba685992c67888db73aa6e78ddc2d41725079df06186fab61e615c4cf3f2
+size 2225560

models/catboost_Q3.cbm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:29a7dd613ab06bf185f48e70a4179d83c629f84bba489ddcba151b662c6647fe
+size 2227624

models/catboost_Q4.cbm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0916b0b97fcdf71e14dd6b0b3e4f4a8d652a0717d87b9173dc094ac558ad1696
+size 2228928

models/catboost_Q4_enhanced.cbm

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:058ddc80f29acf6eab048d425f0ede4f29145969e708daa5e48a94127b809e94
+size 565688

pytest.ini

@@ -0,0 +1,3 @@
+[pytest]
+testpaths = tests
+pythonpath = .

quick_test.py

@@ -0,0 +1,58 @@
+### **3. `quick_test.py`** (быстрая проверка)
+```python
+# !/usr/bin/env python3
+"""
+Быстрая проверка работы системы
+"""
+
+import subprocess
+import sys
+import os
+
+
+def run_command(cmd):
+    """Запускает команду и возвращает результат"""
+    try:
+        result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+        return result.returncode == 0, result.stdout, result.stderr
+    except Exception as e:
+        return False, "", str(e)
+
+
+def main():
+    print("🚀 БЫСТРАЯ ПРОВЕРКА СИСТЕМЫ")
+    print("=" * 50)
+
+    # 1. Проверяем зависимости
+    print("1. Проверка зависимостей...")
+    success, out, err = run_command(
+        "python -c \"import catboost, fastapi, streamlit; print('✅ Все зависимости установлены')\"")
+    if success:
+        print("   ✅ Все зависимости установлены")
+    else:
+        print("   ❌ Ошибка зависимостей:", err)
+        return
+
+    # 2. Проверяем модели
+    print("2. Проверка ML моделей...")
+    models = ["catboost_Q1.cbm", "catboost_Q2.cbm", "catboost_Q3.cbm", "catboost_Q4.cbm"]
+    all_models_exist = all(os.path.exists(f"models/{model}") for model in models)
+    if all_models_exist:
+        print("   ✅ Все ML модели найдены")
+    else:
+        print("   ❌ Не все модели найдены")
+        return
+
+    # 3. Проверяем данные
+    print("3. Проверка данных...")
+    if os.path.exists("data/raw/small.csv"):
+        print("   ✅ Тестовые данные найдены")
+    else:
+        print("   ⚠️ Тестовые данные не найдены")
+
+    print("\n🎉 СИСТЕМА ГОТОВА К РАБОТЕ!")
+    print("Запустите: docker-compose up")
+
+
+if __name__ == "__main__":
+    main()

retrain_q4.py

@@ -0,0 +1,72 @@
+import pandas as pd
+import numpy as np
+from catboost import CatBoostRegressor
+import sys
+import os
+
+sys.path.append('src')
+
+from features_q4 import enhanced_q4_features
+from features import build_baseline_features
+from semantic_features import add_semantic_similarity
+from data_cleaning import prepare_dataframe
+
+
+def retrain_q4_model():
+    print("🔄 Переобучение модели Q4 с улучшенными фичами...")
+
+    # 1. Загрузи данные
+    df = pd.read_csv('data/raw/Данные для кейса.csv', sep=';')
+    print(f"📊 Загружено {len(df)} строк")
+
+    # 2. Подготовь данные только для Q4
+    df_clean = prepare_dataframe(df)
+    df_q4 = df_clean[df_clean['question_number'] == 4]
+    print(f"📋 Q4 данных: {len(df_q4)} строк")
+
+    # 3. Построй все фичи
+    print("🔨 Строим фичи...")
+    feats = build_baseline_features(df_q4)
+    feats = add_semantic_similarity(feats, verbose=False)
+    feats = enhanced_q4_features(feats)
+
+    # 4. Выдели фичи и целевую переменную
+    feature_cols = [c for c in feats.columns if c.startswith('q4_') or c in [
+        'semantic_sim', 'ans_len_words', 'ans_n_sents', 'ans_ttr',
+        'ans_short_sent_rt', 'ans_punct_rt', 'q_len_words'
+    ]]
+
+    X = feats[feature_cols].fillna(0)
+    y = feats['score'].fillna(0)
+
+    print(f"🎯 Фичей: {len(feature_cols)}, Примеров: {len(X)}")
+    print(f"📈 Фичи: {feature_cols}")
+
+    # 5. Обучи новую модель
+    print("🤖 Обучаем CatBoost...")
+    model = CatBoostRegressor(
+        iterations=500,
+        learning_rate=0.1,
+        depth=6,
+        verbose=100,
+        random_state=42
+    )
+
+    model.fit(X, y)
+
+    # 6. Сохрани модель
+    model.save_model('models/catboost_Q4_enhanced.cbm')
+    print("✅ Модель Q4 переобучена с улучшенными фичами!")
+
+    # 7. Проверим важность фич
+    feature_importance = pd.DataFrame({
+        'feature': feature_cols,
+        'importance': model.get_feature_importance()
+    }).sort_values('importance', ascending=False)
+
+    print("\n📊 Важность фич:")
+    print(feature_importance.head(10))
+
+
+if __name__ == "__main__":
+    retrain_q4_model()

run.py

@@ -0,0 +1,4 @@
+import uvicorn
+
+if __name__ == "__main__":
+    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)

run_predict.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+"""
+Упрощенный запуск предсказания
+"""
+import os
+import sys
+
+# Устанавливаем PYTHONPATH
+current_dir = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, current_dir)
+
+
+def main():
+    print("🚀 ЗАПУСК ПРЕДСКАЗАНИЯ")
+
+    # Импортируем после установки PYTHONPATH
+    from src.predict import pipeline_infer
+
+    # Запускаем предсказание
+    input_file = "data/raw/small.csv"
+    output_file = "predictions_final.csv"
+
+    print(f"📁 Входной файл: {input_file}")
+    print(f"📁 Выходной файл: {output_file}")
+
+    pipeline_infer(input_file, output_file)
+    print("🎉 ПРЕДСКАЗАНИЕ ЗАВЕРШЕНО!")
+
+
+if __name__ == "__main__":
+    main()

runtime.txt

@@ -0,0 +1 @@
+python-3.10

serverless-container.yaml.py

@@ -0,0 +1,28 @@
+name: exam-scorer-api
+spec:
+  connectivity:
+    network_id: default
+  containers:
+    - name: api
+      image: cr.yandex/your-registry-id/exam-scorer:latest
+      command:
+        - python
+        - -m
+        - uvicorn
+        - app.main:api
+        - --host
+        - 0.0.0.0
+        - --port
+        - "8000"
+      ports:
+        - containerPort: 8000
+        protocol: TCP
+      resources:
+        memory: "2048MB"
+        cores: "1"
+      probes:
+        http:
+          path: /health
+          port: 8000
+          initialDelaySeconds: 10
+          periodSeconds: 5

setup.py

@@ -0,0 +1,32 @@
+import os
+import sys
+import subprocess
+
+
+def setup_environment():
+    """Устанавливает PYTHONPATH и возвращает команду для запуска"""
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+
+    # Добавляем в PYTHONPATH
+    if current_dir not in sys.path:
+        sys.path.insert(0, current_dir)
+
+    # Устанавливаем переменную окружения для дочерних процессов
+    os.environ['PYTHONPATH'] = current_dir + os.pathsep + os.environ.get('PYTHONPATH', '')
+
+    print(f"✅ PYTHONPATH установлен: {current_dir}")
+    return current_dir
+
+
+if __name__ == "__main__":
+    setup_environment()
+
+    # Теперь можно запускать predict.py
+    print("🚀 Запуск predict.py...")
+    try:
+        from src.predict import pipeline_infer
+
+        pipeline_infer("data/raw/small.csv", "predictions.csv")
+        print("✅ Предсказание завершено!")
+    except Exception as e:
+        print(f"❌ Ошибка: {e}")

simple_app.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+import streamlit as st
+from transformers import pipeline
+import os
+
+# Отключаем предупреждения
+os.environ["HF_HUB_DISABLE_SYMLINKS_WARNING"] = "1"
+
+# Простая конфигурация
+st.set_page_config(
+    page_title="AI Model Demo",
+    page_icon="🤖",
+    layout="wide"
+)
+
+# Простой заголовок
+st.title("🤖 Демо AI Моделей")
+st.write("Тестирование моделей машинного обучения")
+
+# Боковая панель
+st.sidebar.header("Настройки")
+
+# Выбор задачи
+task = st.sidebar.selectbox(
+    "Выберите задачу:",
+    ["Анализ тональности", "Генерация текста", "Классификация"]
+)
+
+# Основной контент
+if task == "Анализ тональности":
+    st.header("📊 Анализ тональности текста")
+    text = st.text_area("Введите текст:", "Я очень рад этому!")
+
+    if st.button("Анализировать"):
+        with st.spinner("Анализируем..."):
+            try:
+                classifier = pipeline("sentiment-analysis")
+                result = classifier(text)[0]
+                st.success(f"Результат: {result['label']}")
+                st.info(f"Уверенность: {result['score']:.4f}")
+            except Exception as e:
+                st.error(f"Ошибка: {e}")
+
+elif task == "Генерация текста":
+    st.header("✍️ Генерация текста")
+    prompt = st.text_area("Введите начало текста:", "Искусственный интеллект")
+
+    if st.button("Сгенерировать"):
+        with st.spinner("Генерируем..."):
+            try:
+                generator = pipeline("text-generation", model="gpt2")
+                result = generator(prompt, max_length=100, num_return_sequences=1)
+                st.write("**Результат:**")
+                st.write(result[0]['generated_text'])
+            except Exception as e:
+                st.error(f"Ошибка: {e}")
+
+elif task == "Классификация":
+    st.header("🏷️ Классификация текста")
+    text = st.text_area("Введите текст для классификации:", "Это потрясающий продукт!")
+
+    if st.button("Классифицировать"):
+        with st.spinner("Классифицируем..."):
+            try:
+                classifier = pipeline("text-classification")
+                results = classifier(text)
+                st.write("**Результаты:**")
+                for result in results:
+                    st.write(f"- {result['label']}: {result['score']:.4f}")
+            except Exception as e:
+                st.error(f"Ошибка: {e}")
+
+# Информация внизу
+st.sidebar.markdown("---")
+st.sidebar.info("Простое демо для тестирования моделей")

src/add_q4_features.py

@@ -0,0 +1,22 @@
+# src/add_q4_features.py
+from pathlib import Path
+import pandas as pd
+from src.features_q4 import q4_slot_features
+
+ROOT = Path(__file__).resolve().parents[1]
+INP  = ROOT / "data" / "processed" / "features_with_semantics.csv"   # уже есть
+OUT  = ROOT / "data" / "processed" / "features_with_semantics_q4.csv"
+
+def main():
+    df = pd.read_csv(INP, encoding="utf-8-sig")
+    df2 = q4_slot_features(df)
+    OUT.parent.mkdir(parents=True, exist_ok=True)
+    df2.to_csv(OUT, index=False, encoding="utf-8-sig")
+    print("✅ Сохранено:", OUT)
+    print(df2[[
+        "question_number","semantic_sim",
+        "q4_slots_covered","q4_answered_personal","q4_non_cyr_ratio","score"
+    ]].head())
+
+if __name__ == "__main__":
+    main()