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

README.md

@@ -1,19 +1,100 @@
 ---
-title: TimeSeriesHomework1 2
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
+title: TimeSeriesHomework - Анализ и прогнозирование временных рядов
+emoji: 📊
+colorFrom: blue
+colorTo: purple
+sdk: streamlit
 app_port: 8501
 tags:
 - streamlit
+- timeseries
+- forecasting
+- machine-learning
 pinned: false
-short_description: Streamlit template space
+short_description: Веб-приложение для анализа и прогнозирования временных рядов
 ---
 
-# Welcome to Streamlit!
+# 📊 Анализ и прогнозирование временных рядов
 
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
+Веб-приложение на Streamlit для выполнения двух лабораторных работ по анализу временных рядов.
 
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+## 🚀 Быстрый старт
+
+```bash
+pip install -r requirements.txt
+streamlit run src/streamlit_app.py
+```
+
+Откройте браузер: `http://localhost:8501`
+
+## 📚 Документация
+
+- **[БЫСТРЫЙ_СТАРТ.md](БЫСТРЫЙ_СТАРТ.md)** - Краткая шпаргалка для быстрого начала работы
+- **[РУКОВОДСТВО.md](РУКОВОДСТВО.md)** - Подробное руководство по использованию программы
+- **[СТРУКТУРА_КОДА.md](СТРУКТУРА_КОДА.md)** - Описание структуры кода проекта
+
+## 🧪 Лабораторные работы
+
+### ЛР №1: Введение в анализ временных рядов
+- Сбор и предобработка данных
+- Описательная статистика и визуализация
+- Проверка стационарности
+- Создание лагов и скользящих статистик
+- Анализ автокорреляции (ACF/PACF)
+- Декомпозиция временного ряда
+- Генерация HTML-отчёта
+
+### ЛР №2: Прогнозирование временных рядов
+- Углублённая декомпозиция
+- Расширенный feature engineering
+- Стратегии многопшагового прогнозирования
+- Кросс-валидация для временных рядов
+- Преобразования к стационарности (Box-Cox, дифференцирование)
+- Модели экспоненциального сглаживания (SES, Holt)
+- Диагностика остатков моделей
+- Сравнительный анализ моделей
+
+## 📁 Структура проекта
+
+```
+TimeSeriesHomework/
+├── src/
+│   ├── streamlit_app.py      # Главное веб-приложение
+│   ├── lab2_functions.py     # Функции для ЛР №2
+│   └── russia_covid_dataset.csv # Пример данных
+├── requirements.txt          # Зависимости Python
+├── РУКОВОДСТВО.md           # Подробное руководство
+├── БЫСТРЫЙ_СТАРТ.md         # Краткая шпаргалка
+└── СТРУКТУРА_КОДА.md        # Структура кода
+```
+
+## 🛠️ Технологии
+
+- **Streamlit** - веб-интерфейс
+- **Pandas** - работа с данными
+- **NumPy** - численные вычисления
+- **Plotly** - интерактивные графики
+- **Statsmodels** - статистические модели
+- **Scipy** - научные вычисления
+- **Scikit-learn** - машинное обучение
+
+## 📖 Использование
+
+1. **Запустите приложение** (см. Быстрый старт)
+2. **Выберите лабораторную работу** в боковой панели
+3. **Следуйте инструкциям** в интерфейсе
+4. **Изучите документацию** для подробного понимания
+
+## 💡 Советы
+
+- Начните с **БЫСТРЫЙ_СТАРТ.md** для быстрого начала
+- Используйте **РУКОВОДСТВО.md** для подробного понимания
+- Смотрите **СТРУКТУРА_КОДА.md** для понимания кода
+
+## 📝 Лицензия
+
+Проект создан для учебных целей.
+
+---
+
+**Вопросы?** См. документацию в файлах `РУКОВОДСТВО.md` и `БЫСТРЫЙ_СТАРТ.md`

requirements.txt

@@ -7,3 +7,5 @@ statsmodels
 scikit-learn
 matplotlib
 pdfkit
+scipy
+seaborn

src/lab2_functions.py

@@ -0,0 +1,626 @@
+"""
+Функции для лабораторной работы №2: Прогнозирование временных рядов
+"""
+import numpy as np
+import pandas as pd
+from typing import List, Tuple, Dict, Optional
+from scipy import stats
+from scipy.stats import boxcox, boxcox_normmax
+from statsmodels.tsa.holtwinters import ExponentialSmoothing
+from statsmodels.stats.diagnostic import acorr_ljungbox
+from statsmodels.tsa.stattools import adfuller, kpss
+from sklearn.model_selection import TimeSeriesSplit
+from sklearn.metrics import mean_absolute_error, mean_squared_error
+import warnings
+warnings.filterwarnings('ignore')
+
+
+def calculate_mape(y_true: np.ndarray, y_pred: np.ndarray) -> float:
+    """Вычисляет MAPE (Mean Absolute Percentage Error)"""
+    y_true = np.array(y_true)
+    y_pred = np.array(y_pred)
+    mask = y_true != 0
+    if mask.sum() == 0:
+        return np.nan
+    return np.mean(np.abs((y_true[mask] - y_pred[mask]) / y_true[mask])) * 100
+
+
+def create_advanced_features(df: pd.DataFrame, target: str, timestamp_col: str = 'timestamp') -> pd.DataFrame:
+    """
+    Расширенный feature engineering:
+    - Временные признаки (день недели, месяц, квартал)
+    - Циклические признаки через sin/cos
+    - Лаги: lag_1, lag_7, lag_30
+    - Скользящие статистики: mean, std, min, max по окнам 7, 30, 90
+    """
+    df = df.copy()
+    df = df.set_index(timestamp_col).sort_index()
+    
+    # Временные признаки
+    df['day_of_week'] = df.index.dayofweek
+    df['month'] = df.index.month
+    df['quarter'] = df.index.quarter
+    df['day_of_month'] = df.index.day
+    df['week_of_year'] = df.index.isocalendar().week
+    
+    # Циклические признаки
+    df['day_of_week_sin'] = np.sin(2 * np.pi * df['day_of_week'] / 7)
+    df['day_of_week_cos'] = np.cos(2 * np.pi * df['day_of_week'] / 7)
+    df['month_sin'] = np.sin(2 * np.pi * df['month'] / 12)
+    df['month_cos'] = np.cos(2 * np.pi * df['month'] / 12)
+    
+    # Лаги
+    for lag in [1, 7, 30]:
+        df[f'{target}_lag_{lag}'] = df[target].shift(lag)
+    
+    # Скользящие статистики
+    windows = [7, 30, 90]
+    for w in windows:
+        df[f'{target}_rolling_mean_{w}'] = df[target].rolling(window=w, min_periods=1).mean()
+        df[f'{target}_rolling_std_{w}'] = df[target].rolling(window=w, min_periods=1).std()
+        df[f'{target}_rolling_min_{w}'] = df[target].rolling(window=w, min_periods=1).min()
+        df[f'{target}_rolling_max_{w}'] = df[target].rolling(window=w, min_periods=1).max()
+    
+    # Коэффициент вариации (волатильность)
+    for w in [7, 30]:
+        rolling_mean = df[f'{target}_rolling_mean_{w}']
+        rolling_std = df[f'{target}_rolling_std_{w}']
+        df[f'{target}_rolling_cv_{w}'] = rolling_std / (rolling_mean + 1e-8)
+    
+    return df.reset_index()
+
+
+def apply_boxcox_transform(series: pd.Series, lambda_param: Optional[float] = None) -> Tuple[pd.Series, float]:
+    """
+    Применяет преобразование Бокса-Кокса.
+    Если lambda_param не указан, подбирает оптимальный.
+    """
+    series_positive = series[series > 0]
+    if len(series_positive) == 0:
+        raise ValueError("Все значения должны быть положительными для преобразования Бокса-Кокса")
+    
+    if lambda_param is None:
+        # Автоматический подбор lambda
+        lambda_param = boxcox_normmax(series_positive.values)
+    
+    transformed_values, fitted_lambda = boxcox(series_positive.values, lmbda=lambda_param)
+    
+    # Создаём новый Series с теми же индексами
+    result = pd.Series(index=series.index, dtype=float)
+    result.loc[series > 0] = transformed_values
+    
+    return result, fitted_lambda
+
+
+def inverse_boxcox_transform(transformed_series: pd.Series, lambda_param: float) -> pd.Series:
+    """Обратное преобразование Бокса-Кокса"""
+    if lambda_param == 0:
+        return np.exp(transformed_series)
+    else:
+        return (lambda_param * transformed_series + 1) ** (1 / lambda_param)
+
+
+def inverse_transformations(
+    forecast: np.ndarray,
+    last_train_values_transformed: np.ndarray,
+    transform_info: Dict
+) -> np.ndarray:
+    """
+    Применяет обратные преобразования к прогнозу.
+    
+    Порядок обратного преобразования должен быть обратным порядку прямого:
+    Прямое: transformation -> diff_order -> seasonal_diff
+    Обратное: seasonal_diff -> diff_order -> transformation
+    
+    forecast: прогноз в преобразованном пространстве (после всех преобразований)
+    last_train_values_transformed: последние значения обучающей выборки в преобразованном пространстве (после всех преобразований)
+    transform_info: информация о применённых преобразованиях (может содержать промежуточные значения)
+    """
+    result = forecast.copy()
+    diff_order = transform_info.get('diff_order', 0)
+    seasonal_diff = transform_info.get('seasonal_diff')
+    
+    # Получаем промежуточные значения из transform_info, если они есть
+    last_values_after_diff = transform_info.get('last_values_after_diff', None)
+    last_values_after_transform = transform_info.get('last_values_after_transform', None)
+    
+    # 1. Обратное сезонное дифференцирование (если было)
+    if seasonal_diff is not None and seasonal_diff > 0:
+        # Нужны последние seasonal_diff значений после transformation и diff, но до seasonal_diff
+        if last_values_after_diff is not None and len(last_values_after_diff) >= seasonal_diff:
+            last_seasonal = last_values_after_diff[-seasonal_diff:]
+        elif len(last_train_values_transformed) >= seasonal_diff:
+            # Fallback: используем последние значения (хотя это не совсем правильно)
+            last_seasonal = last_train_values_transformed[-seasonal_diff:]
+        else:
+            last_seasonal = last_train_values_transformed if len(last_train_values_transformed) > 0 else np.array([0])
+        
+        for i in range(len(result)):
+            if i < len(last_seasonal):
+                result[i] = result[i] + last_seasonal[i]
+            else:
+                # Используем предыдущие прогнозы
+                result[i] = result[i] + result[i - seasonal_diff]
+    
+    # 2. Обратное обычное дифференцирование (если было)
+    for _ in range(diff_order):
+        # Нужны последние diff_order значений после transformation, но до diff
+        if last_values_after_transform is not None and len(last_values_after_transform) > 0:
+            last_val = last_values_after_transform[-1]
+        elif len(last_train_values_transformed) > 0:
+            # Fallback
+            last_val = last_train_values_transformed[-1]
+        else:
+            last_val = 0
+        
+        for i in range(len(result)):
+            if i == 0:
+                result[i] = result[i] + last_val
+            else:
+                result[i] = result[i] + result[i - 1]
+    
+    # 3. Обратное преобразование для стабилизации дисперсии
+    if transform_info.get('transformation') == 'log':
+        result = np.exp(result)
+    elif transform_info.get('transformation') == 'boxcox':
+        lambda_param = transform_info.get('lambda')
+        if lambda_param is not None:
+            if lambda_param == 0:
+                result = np.exp(result)
+            else:
+                result = (lambda_param * result + 1) ** (1 / lambda_param)
+    
+    return result
+
+
+def apply_transformations(
+    series: pd.Series,
+    transformation: str = 'none',
+    lambda_param: Optional[float] = None,
+    diff_order: int = 0,
+    seasonal_diff: Optional[int] = None
+) -> Tuple[pd.Series, Dict]:
+    """
+    Применяет цепочку преобразований к ряду.
+    
+    transformation: 'none', 'log', 'boxcox'
+    diff_order: порядок обычного дифференцирования
+    seasonal_diff: период сезонного дифференцирования
+    
+    Возвращает преобразованный ряд и словарь с информацией о преобразованиях,
+    включая промежуточные значения для обратного преобразования.
+    """
+    result = series.copy()
+    info = {'transformation': transformation, 'lambda': None, 'diff_order': diff_order, 'seasonal_diff': seasonal_diff}
+    
+    # Преобразование для стабилизации дисперсии
+    if transformation == 'log':
+        if (result <= 0).any():
+            raise ValueError("Для лог-трансформации все значения должны быть положительными")
+        result = np.log(result)
+    elif transformation == 'boxcox':
+        result, lambda_param = apply_boxcox_transform(result, lambda_param)
+        info['lambda'] = lambda_param
+    
+    # Сохраняем значения после transformation (для обратного diff)
+    result_after_transform = result.copy()
+    
+    # Обычное дифференцирование
+    for _ in range(diff_order):
+        result = result.diff()
+    
+    # Сохраняем значения после diff (для обратного seasonal_diff)
+    result_after_diff = result.copy()
+    
+    # Сезонное дифференцирование
+    if seasonal_diff is not None and seasonal_diff > 0:
+        result = result.diff(periods=seasonal_diff)
+    
+    # Сохраняем промежуточные значения для обратного преобразования
+    info['last_values_after_transform'] = result_after_transform.values[-max(diff_order, 1):] if len(result_after_transform) > 0 else np.array([])
+    info['last_values_after_diff'] = result_after_diff.values[-max(seasonal_diff if seasonal_diff else 1, 1):] if len(result_after_diff) > 0 else np.array([])
+    
+    return result.dropna(), info
+
+
+def recursive_forecast(
+    model_func,
+    train_data: pd.Series,
+    horizon: int,
+    alpha: Optional[float] = None,
+    **model_kwargs
+) -> Tuple[np.ndarray, Optional[Tuple[np.ndarray, np.ndarray]]]:
+    """
+    Рекурсивная стратегия прогнозирования:
+    Одна модель → итеративное использование прогнозов
+    
+    Возвращает прогнозы и опционально доверительные интервалы (lower, upper)
+    """
+    forecasts = []
+    conf_lower = [] if alpha is not None else None
+    conf_upper = [] if alpha is not None else None
+    current_data = train_data.copy()
+    
+    # Определяем тип индекса для правильного добавления новых значений
+    is_datetime = pd.api.types.is_datetime64_any_dtype(current_data.index)
+    
+    for h in range(horizon):
+        # Обучаем модель на текущих данных
+        model = model_func(current_data, **model_kwargs)
+        # Прогнозируем на 1 шаг вперёд
+        if alpha is not None:
+            try:
+                forecast_result = model.forecast(steps=1, alpha=alpha)
+                if isinstance(forecast_result, tuple):
+                    forecast_value = forecast_result[0][0] if len(forecast_result[0]) > 0 else forecast_result[0]
+                    if len(forecast_result) > 1:
+                        conf_lower.append(forecast_result[1][0] if len(forecast_result[1]) > 0 else forecast_result[1])
+                        conf_upper.append(forecast_result[2][0] if len(forecast_result[2]) > 0 else forecast_result[2])
+                else:
+                    forecast_value = forecast_result[0] if hasattr(forecast_result, '__getitem__') else float(forecast_result)
+            except:
+                # Если доверительные интервалы не поддерживаются, используем обычный прогноз
+                forecast = model.forecast(steps=1)
+                forecast_value = forecast[0] if hasattr(forecast, '__getitem__') else float(forecast)
+        else:
+            forecast = model.forecast(steps=1)
+            forecast_value = forecast[0] if hasattr(forecast, '__getitem__') else float(forecast)
+        
+        forecasts.append(forecast_value)
+        
+        # Добавляем прогноз к данным для следующей итерации
+        if is_datetime:
+            # Для DatetimeIndex используем частоту или инференс
+            try:
+                freq = pd.infer_freq(current_data.index) or 'D'
+                # Используем pd.date_range для создания следующей даты
+                last_date = current_data.index[-1]
+                next_dates = pd.date_range(start=last_date, periods=2, freq=freq)
+                if len(next_dates) >= 2:
+                    next_idx = next_dates[1]  # Берём вторую дату (первая = last_date)
+                else:
+                    # Fallback
+                    next_idx = len(current_data)
+                    is_datetime = False
+            except:
+                # Если не удалось определить частоту, используем числовой индекс
+                try:
+                    # Пробуем простой способ через Timedelta
+                    next_idx = current_data.index[-1] + pd.Timedelta(days=1)
+                except:
+                    next_idx = len(current_data)
+                    is_datetime = False
+        else:
+            # Для числового индекса просто увеличиваем на 1
+            next_idx = len(current_data)
+        
+        if is_datetime:
+            current_data = pd.concat([current_data, pd.Series([forecast_value], index=[next_idx])])
+        else:
+            # Используем числовой индекс
+            current_data = pd.concat([current_data, pd.Series([forecast_value], index=[next_idx])])
+    
+    result = np.array(forecasts)
+    if alpha is not None and conf_lower and conf_upper:
+        return result, (np.array(conf_lower), np.array(conf_upper))
+    return result, None
+
+
+def direct_forecast(
+    model_func,
+    train_data: pd.Series,
+    horizon: int,
+    alpha: Optional[float] = None,
+    **model_kwargs
+) -> Tuple[np.ndarray, Optional[Tuple[np.ndarray, np.ndarray]]]:
+    """
+    Прямая стратегия прогнозирования:
+    Отдельная модель для каждого шага t+1, ..., t+h
+    
+    Возвращает прогнозы и опционально доверительные интервалы (lower, upper)
+    """
+    forecasts = []
+    conf_lower = [] if alpha is not None else None
+    conf_upper = [] if alpha is not None else None
+    
+    for h in range(1, horizon + 1):
+        # Обучаем отдельную модель для шага h
+        model = model_func(train_data, **model_kwargs)
+        # Прогнозируем на h шагов вперёд и берём последний
+        if alpha is not None:
+            try:
+                forecast_result = model.forecast(steps=h, alpha=alpha)
+                if isinstance(forecast_result, tuple):
+                    forecast_value = forecast_result[0][-1] if len(forecast_result[0]) > 0 else forecast_result[0]
+                    if len(forecast_result) > 1:
+                        conf_lower.append(forecast_result[1][-1] if len(forecast_result[1]) > 0 else forecast_result[1])
+                        conf_upper.append(forecast_result[2][-1] if len(forecast_result[2]) > 0 else forecast_result[2])
+                else:
+                    forecast_value = forecast_result[-1]
+            except:
+                forecast = model.forecast(steps=h)
+                forecast_value = forecast[-1]
+        else:
+            forecast = model.forecast(steps=h)
+            forecast_value = forecast[-1]
+        
+        forecasts.append(forecast_value)
+    
+    result = np.array(forecasts)
+    if alpha is not None and conf_lower and conf_upper:
+        return result, (np.array(conf_lower), np.array(conf_upper))
+    return result, None
+
+
+def hybrid_forecast(
+    model_func,
+    train_data: pd.Series,
+    horizon: int,
+    recursive_steps: int = None,
+    alpha: Optional[float] = None,
+    **model_kwargs
+) -> Tuple[np.ndarray, Optional[Tuple[np.ndarray, np.ndarray]]]:
+    """
+    Гибридная стратегия:
+    Рекурсивная для ближайших шагов, прямая — для дальних
+    
+    Возвращает прогнозы и опционально доверительные интервалы (lower, upper)
+    """
+    if recursive_steps is None:
+        recursive_steps = max(1, horizon // 2)
+    
+    forecasts = []
+    conf_lower = [] if alpha is not None else None
+    conf_upper = [] if alpha is not None else None
+    
+    # Рекурсивная часть
+    recursive_result = recursive_forecast(model_func, train_data, recursive_steps, alpha=alpha, **model_kwargs)
+    if isinstance(recursive_result, tuple):
+        recursive_forecasts, recursive_conf = recursive_result
+        if recursive_conf is not None:
+            conf_lower.extend(recursive_conf[0])
+            conf_upper.extend(recursive_conf[1])
+    else:
+        recursive_forecasts = recursive_result
+    forecasts.extend(recursive_forecasts)
+    
+    # Прямая часть для оставшихся шагов
+    if horizon > recursive_steps:
+        # Используем последние данные + рекурсивные прогнозы
+        is_datetime = pd.api.types.is_datetime64_any_dtype(train_data.index)
+        
+        if is_datetime:
+            try:
+                freq = pd.infer_freq(train_data.index) or 'D'
+                # Используем pd.date_range для создания дат начиная с последней даты + 1 период
+                last_date = train_data.index[-1]
+                extended_index = pd.date_range(
+                    start=last_date,
+                    periods=len(recursive_forecasts) + 1,
+                    freq=freq
+                )[1:]  # Берём все даты кроме первой (которая равна last_date)
+            except:
+                # Fallback на числовой индекс
+                try:
+                    # Пробуем через date_range с periods
+                    last_date = train_data.index[-1]
+                    extended_index = pd.date_range(
+                        start=last_date,
+                        periods=len(recursive_forecasts) + 1,
+                        freq='D'
+                    )[1:]  # Берём все даты кроме первой
+                except:
+                    extended_index = range(len(train_data), len(train_data) + len(recursive_forecasts))
+        else:
+            extended_index = range(len(train_data), len(train_data) + len(recursive_forecasts))
+        
+        extended_data = pd.concat([
+            train_data,
+            pd.Series(recursive_forecasts, index=extended_index)
+        ])
+        
+        remaining_horizon = horizon - recursive_steps
+        direct_result = direct_forecast(model_func, extended_data, remaining_horizon, alpha=alpha, **model_kwargs)
+        if isinstance(direct_result, tuple):
+            direct_forecasts, direct_conf = direct_result
+            if direct_conf is not None:
+                conf_lower.extend(direct_conf[0])
+                conf_upper.extend(direct_conf[1])
+        else:
+            direct_forecasts = direct_result
+        forecasts.extend(direct_forecasts)
+    
+    result = np.array(forecasts[:horizon])
+    if alpha is not None and conf_lower and conf_upper:
+        return result, (np.array(conf_lower[:horizon]), np.array(conf_upper[:horizon]))
+    return result, None
+
+
+def create_exponential_smoothing_model(
+    train_data: pd.Series,
+    trend: Optional[str] = None,
+    seasonal: Optional[str] = None,
+    seasonal_periods: Optional[int] = None,
+    optimized: bool = True
+) -> ExponentialSmoothing:
+    """Создаёт и обучает модель экспоненциального сглаживания"""
+    try:
+        model = ExponentialSmoothing(
+            train_data,
+            trend=trend,
+            seasonal=seasonal,
+            seasonal_periods=seasonal_periods,
+            initialization_method='estimated' if optimized else 'simple'
+        )
+        fitted_model = model.fit(optimized=optimized)
+        return fitted_model
+    except Exception as e:
+        raise ValueError(f"Ошибка при создании модели: {e}")
+
+
+def evaluate_forecast(y_true: np.ndarray, y_pred: np.ndarray) -> Dict[str, float]:
+    """Вычисляет метрики качества прогноза"""
+    y_true = np.array(y_true)
+    y_pred = np.array(y_pred)
+    
+    mae = mean_absolute_error(y_true, y_pred)
+    rmse = np.sqrt(mean_squared_error(y_true, y_pred))
+    mape = calculate_mape(y_true, y_pred)
+    
+    return {
+        'MAE': mae,
+        'RMSE': rmse,
+        'MAPE': mape
+    }
+
+
+def naive_forecast(train_data: pd.Series, horizon: int) -> np.ndarray:
+    """Наивный прогноз: y[t+h] = y[t]"""
+    last_value = train_data.iloc[-1]
+    return np.full(horizon, last_value)
+
+
+def time_series_cv_sliding_window(
+    model_func,
+    data: pd.Series,
+    train_size: int,
+    test_size: int,
+    horizon: int,
+    step: int = 1,
+    **model_kwargs
+) -> List[Dict]:
+    """
+    Кросс-валидация со скользящим окном (фиксированная длина обучения)
+    """
+    results = []
+    n = len(data)
+    
+    for i in range(0, n - train_size - test_size + 1, step):
+        train_end = i + train_size
+        test_end = min(train_end + test_size, n)
+        
+        train_data = data.iloc[i:train_end]
+        test_data = data.iloc[train_end:test_end]
+        
+        try:
+            model = model_func(train_data, **model_kwargs)
+            forecast = model.forecast(steps=min(horizon, len(test_data)))
+            
+            metrics = evaluate_forecast(test_data.values[:len(forecast)], forecast)
+            metrics['fold'] = len(results) + 1
+            metrics['train_start'] = train_data.index[0]
+            metrics['train_end'] = train_data.index[-1]
+            metrics['test_start'] = test_data.index[0]
+            metrics['test_end'] = test_data.index[-1]
+            results.append(metrics)
+        except Exception as e:
+            print(f"Ошибка в фолде {len(results) + 1}: {e}")
+    
+    return results
+
+
+def time_series_cv_expanding_window(
+    model_func,
+    data: pd.Series,
+    initial_train_size: int,
+    test_size: int,
+    horizon: int,
+    step: int = 1,
+    **model_kwargs
+) -> List[Dict]:
+    """
+    Кросс-валидация с расширяющимся окном (обучение растёт со временем)
+    """
+    results = []
+    n = len(data)
+    
+    for i in range(initial_train_size, n - test_size + 1, step):
+        train_end = i
+        test_end = min(train_end + test_size, n)
+        
+        train_data = data.iloc[:train_end]
+        test_data = data.iloc[train_end:test_end]
+        
+        try:
+            model = model_func(train_data, **model_kwargs)
+            forecast = model.forecast(steps=min(horizon, len(test_data)))
+            
+            metrics = evaluate_forecast(test_data.values[:len(forecast)], forecast)
+            metrics['fold'] = len(results) + 1
+            metrics['train_start'] = train_data.index[0]
+            metrics['train_end'] = train_data.index[-1]
+            metrics['test_start'] = test_data.index[0]
+            metrics['test_end'] = test_data.index[-1]
+            results.append(metrics)
+        except Exception as e:
+            print(f"Ошибка в фолде {len(results) + 1}: {e}")
+    
+    return results
+
+
+def diagnose_model_residuals(residuals: np.ndarray, lags: int = 10) -> Dict:
+    """
+    Диагностика остатк��в модели:
+    - Тест Льюнга-Бокса на автокорреляцию
+    - Проверка нормальности (Shapiro-Wilk)
+    - Q-Q plot данные
+    """
+    residuals_clean = residuals[~np.isnan(residuals)]
+    
+    if len(residuals_clean) < 3:
+        return {'error': 'Недостаточно данных для диагностики'}
+    
+    results = {}
+    
+    # Тест Льюнга-Бокса
+    try:
+        lb_stat, lb_pvalue = acorr_ljungbox(residuals_clean, lags=min(lags, len(residuals_clean) - 1), return_df=False)
+        results['ljung_box'] = {
+            'statistic': float(lb_stat[-1]) if len(lb_stat) > 0 else None,
+            'pvalue': float(lb_pvalue[-1]) if len(lb_pvalue) > 0 else None,
+            'lags': lags
+        }
+    except Exception as e:
+        results['ljung_box'] = {'error': str(e)}
+    
+    # Тест Шапиро-Уилка на нормальность
+    try:
+        if len(residuals_clean) <= 5000:  # Ограничение для Shapiro-Wilk
+            shapiro_stat, shapiro_pvalue = stats.shapiro(residuals_clean)
+            results['shapiro_wilk'] = {
+                'statistic': float(shapiro_stat),
+                'pvalue': float(shapiro_pvalue)
+            }
+        else:
+            # Для больших выборок используем тест нормальности из scipy
+            k2_stat, k2_pvalue = stats.normaltest(residuals_clean)
+            results['normality_test'] = {
+                'statistic': float(k2_stat),
+                'pvalue': float(k2_pvalue),
+                'test': 'normaltest'
+            }
+    except Exception as e:
+        results['normality_test'] = {'error': str(e)}
+    
+    # Статистики остатков
+    results['residual_stats'] = {
+        'mean': float(np.mean(residuals_clean)),
+        'std': float(np.std(residuals_clean)),
+        'min': float(np.min(residuals_clean)),
+        'max': float(np.max(residuals_clean)),
+        'count': len(residuals_clean)
+    }
+    
+    # Проверка стационарности остатков
+    try:
+        adf_stat, adf_pvalue, _, _, _, _ = adfuller(residuals_clean)
+        kpss_stat, kpss_pvalue, _, _ = kpss(residuals_clean)
+        results['stationarity'] = {
+            'adf': {'statistic': float(adf_stat), 'pvalue': float(adf_pvalue)},
+            'kpss': {'statistic': float(kpss_stat), 'pvalue': float(kpss_pvalue)}
+        }
+    except Exception as e:
+        results['stationarity'] = {'error': str(e)}
+    
+    return results
+

src/main.py

@@ -0,0 +1,7 @@
+"""
+Главная страница приложения - навигация между лабораторными работами
+Этот файл не используется, так как основное приложение находится в streamlit_app.py
+"""
+# Этот файл оставлен для совместимости, но основное приложение находится в streamlit_app.py
+# Для запуска используйте: streamlit run src/streamlit_app.py
+

src/streamlit_app.py

@@ -8,15 +8,39 @@ import streamlit as st
 import plotly.express as px
 import plotly.graph_objects as go
 import matplotlib.pyplot as plt
+from scipy import stats as scipy_stats
 from statsmodels.tsa.stattools import adfuller, kpss, acf as sm_acf, pacf as sm_pacf
 from statsmodels.graphics.tsaplots import plot_acf, plot_pacf
 from statsmodels.tsa.seasonal import seasonal_decompose
 from statsmodels.stats.outliers_influence import variance_inflation_factor
 from statsmodels.tools import add_constant
 
-st.set_page_config(page_title="TS Preprocess & EDA (3.2–3.8)", layout="wide")
+st.set_page_config(page_title="Анализ временных рядов", layout="wide", initial_sidebar_state="expanded")
 MOSCOW = pytz.timezone("Europe/Moscow")
 
+# Импорт функций для ЛР №2
+import sys
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+try:
+    from lab2_functions import (
+        create_advanced_features, apply_transformations, apply_boxcox_transform, inverse_boxcox_transform,
+        inverse_transformations, recursive_forecast, direct_forecast, hybrid_forecast, create_exponential_smoothing_model,
+        evaluate_forecast, naive_forecast, time_series_cv_sliding_window, time_series_cv_expanding_window,
+        diagnose_model_residuals, calculate_mape
+    )
+    LAB2_AVAILABLE = True
+except ImportError as e:
+    LAB2_AVAILABLE = False
+    st.warning(f"Функции ЛР №2 недоступны: {e}")
+
+# Навигация между лабораторными работами
+st.sidebar.title("🧪 Лабораторные работы")
+lab_choice = st.sidebar.radio(
+    "Выберите лабораторную работу:",
+    ["ЛР №1: Введение в анализ временных рядов", "ЛР №2: Прогнозирование временных рядов"],
+    index=0
+)
+
 
 # ---------------- Utilities ----------------
 def detect_date_column(df: pd.DataFrame) -> Optional[str]:
@@ -335,97 +359,99 @@ def generate_html_report(
     return html
 
 
-# ---------------- Streamlit UI ----------------
-st.title("Временные ряды — предобработка, EDA, стационарность, лаги, ACF/PACF, декомпозиция и экспорт (3.2–3.8)")
+# ---------------- Функция для отображения ЛР №1 ----------------
+def render_lab1():
+    st.title("🧪 Лабораторная работа №1: Введение в анализ временных рядов")
+    st.markdown("**Этапы:** Сбор, очистка, визуализация и диагностика многомерных данных")
 
-# Sidebar
-st.sidebar.header("Настройки")
-uploaded_file = st.sidebar.file_uploader("Загрузите CSV/Parquet", type=['csv', 'parquet'])
+    # Sidebar
+    st.sidebar.header("Настройки")
+    uploaded_file = st.sidebar.file_uploader("Загрузите CSV/Parquet", type=['csv', 'parquet'])
 
-# small built-in example option (uses local file if present)
-sample_option = None
-if os.path.exists('russia_covid_dataset.csv'):
-    sample_option = 'russia_covid_dataset.csv'
-sample_choice = st.sidebar.selectbox('Или выбрать предзагруженный пример', options=[None, sample_option] if sample_option else [None])
+    # small built-in example option (uses local file if present)
+    sample_option = None
+    if os.path.exists('russia_covid_dataset.csv'):
+        sample_option = 'russia_covid_dataset.csv'
+    sample_choice = st.sidebar.selectbox('Или выбрать предзагруженный пример', options=[None, sample_option] if sample_option else [None])
 
-tz_assume = st.sidebar.selectbox("Как трактовать tz-naive метки?",
+    tz_assume = st.sidebar.selectbox("Как трактовать tz-naive метки?",
                                  options=['local', 'utc', 'keep'], index=0,
                                  format_func=lambda x: {'local': 'локально (Europe/Moscow)', 'utc': 'UTC->Moscow', 'keep': 'не трогать'}[x])
-numeric_missing_strategy = st.sidebar.selectbox("Заполнение пропусков (числ.)", options=['interpolate', 'drop', 'rolling'], index=0)
-cat_missing_strategy = st.sidebar.selectbox("Заполнение пропусков (категор.)", options=['mode', 'unknown'], index=0)
-outlier_strategy = st.sidebar.selectbox("Обработка выбросов", options=['interpolate', 'winsorize', 'drop', 'mark'], index=0)
-resample_freq = st.sidebar.selectbox("Ресемплить к частоте (если нужно)", options=[None, 'D', 'W', 'M'], index=1)
+    numeric_missing_strategy = st.sidebar.selectbox("Заполнение пропусков (числ.)", options=['interpolate', 'drop', 'rolling'], index=0)
+    cat_missing_strategy = st.sidebar.selectbox("Заполнение пропусков (категор.)", options=['mode', 'unknown'], index=0)
+    outlier_strategy = st.sidebar.selectbox("Обработка выбросов", options=['interpolate', 'winsorize', 'drop', 'mark'], index=0)
+    resample_freq = st.sidebar.selectbox("Ресемплить к частоте (если нужно)", options=[None, 'D', 'W', 'M'], index=1)
 
-# load dataset and persist
-if 'df_in' not in st.session_state:
-    st.session_state['df_in'] = None
+    # load dataset and persist
+    if 'df_in' not in st.session_state:
+        st.session_state['df_in'] = None
 
-if uploaded_file is not None:
-    try:
-        if uploaded_file.name.endswith('.parquet'):
-            df_in = pd.read_parquet(uploaded_file)
-        else:
-            df_in = pd.read_csv(uploaded_file, low_memory=False)
-        st.session_state['df_in'] = df_in
-        st.success(f"Загружен файл: {uploaded_file.name} ({df_in.shape[0]}×{df_in.shape[1]})")
-    except Exception as e:
-        st.error(f"Ошибка загрузки: {e}")
-        st.stop()
-elif sample_choice:
-    st.session_state['df_in'] = pd.read_csv(sample_choice, low_memory=False)
-    st.info(f"Выбран пример: {sample_choice}")
-else:
-    local_path = 'russia_covid_dataset.csv'
-    if st.session_state['df_in'] is None and os.path.exists(local_path):
-        st.session_state['df_in'] = pd.read_csv(local_path, low_memory=False)
-        st.info(f"Авто-загружен локальный файл {local_path}")
-    elif st.session_state['df_in'] is None:
-        st.info("Загрузите файл или поместите russia_covid_dataset.csv в рабочую папку.")
+    if uploaded_file is not None:
+        try:
+            if uploaded_file.name.endswith('.parquet'):
+                df_in = pd.read_parquet(uploaded_file)
+            else:
+                df_in = pd.read_csv(uploaded_file, low_memory=False)
+            st.session_state['df_in'] = df_in
+            st.success(f"Загружен файл: {uploaded_file.name} ({df_in.shape[0]}×{df_in.shape[1]})")
+        except Exception as e:
+            st.error(f"Ошибка загрузки: {e}")
+            st.stop()
+    elif sample_choice:
+        st.session_state['df_in'] = pd.read_csv(sample_choice, low_memory=False)
+        st.info(f"Выбран пример: {sample_choice}")
+    else:
+        local_path = 'russia_covid_dataset.csv'
+        if st.session_state['df_in'] is None and os.path.exists(local_path):
+            st.session_state['df_in'] = pd.read_csv(local_path, low_memory=False)
+            st.info(f"Авто-загружен локальный файл {local_path}")
+        elif st.session_state['df_in'] is None:
+            st.info("Загрузите файл или поместите russia_covid_dataset.csv в рабочую папку.")
+            st.stop()
+
+
+    df_in = st.session_state['df_in']
+    st.subheader("Preview входного датасета")
+    st.dataframe(df_in.head(8))
+
+    # detect date column
+    detected = detect_date_column(df_in)
+    col_for_date = st.text_input("Колонка с временной меткой", value=detected if detected else "")
+    if not col_for_date:
+        st.error("Укажите колонку с временной меткой.")
         st.stop()
 
-
-df_in = st.session_state['df_in']
-st.subheader("Preview входного датасета")
-st.dataframe(df_in.head(8))
-
-# detect date column
-detected = detect_date_column(df_in)
-col_for_date = st.text_input("Колонка с временной меткой", value=detected if detected else "")
-if not col_for_date:
-    st.error("Укажите колонку с временной меткой.")
-    st.stop()
-
-# Run buttons
-col1, col2 = st.columns([1, 1])
-with col1:
-    run_btn = st.button("Run Preprocessing")
-with col2:
-    force_btn = st.button("Force Recompute (пересчитать)")
-
-# session keys
-st.session_state.setdefault('preprocessed', False)
-st.session_state.setdefault('df_clean', None)
-st.session_state.setdefault('info', {})
-st.session_state.setdefault('df_lags', None)
-
-if run_btn or force_btn or (not st.session_state['preprocessed'] and st.session_state['df_clean'] is None):
-    df_clean, info = preprocess_timeseries(
-        df_in,
-        date_col=col_for_date,
-        tz_assume=tz_assume,
-        numeric_missing_strategy=numeric_missing_strategy,
-        cat_missing_strategy=cat_missing_strategy,
-        outlier_strategy=outlier_strategy,
-        resample_freq=resample_freq,
-    )
-    st.session_state['df_clean'] = df_clean
-    st.session_state['info'] = info
-    st.session_state['preprocessed'] = True
-
-# Main UI after preprocess
-if st.session_state.get('preprocessed'):
-    df_clean = st.session_state['df_clean']
-    info = st.session_state['info']
+    # Run buttons
+    col1, col2 = st.columns([1, 1])
+    with col1:
+        run_btn = st.button("Run Preprocessing")
+    with col2:
+        force_btn = st.button("Force Recompute (пересчитать)")
+
+    # session keys
+    st.session_state.setdefault('preprocessed', False)
+    st.session_state.setdefault('df_clean', None)
+    st.session_state.setdefault('info', {})
+    st.session_state.setdefault('df_lags', None)
+
+    if run_btn or force_btn or (not st.session_state['preprocessed'] and st.session_state['df_clean'] is None):
+        df_clean, info = preprocess_timeseries(
+            df_in,
+            date_col=col_for_date,
+            tz_assume=tz_assume,
+            numeric_missing_strategy=numeric_missing_strategy,
+            cat_missing_strategy=cat_missing_strategy,
+            outlier_strategy=outlier_strategy,
+            resample_freq=resample_freq,
+        )
+        st.session_state['df_clean'] = df_clean
+        st.session_state['info'] = info
+        st.session_state['preprocessed'] = True
+
+    # Main UI after preprocess
+    if st.session_state.get('preprocessed'):
+        df_clean = st.session_state['df_clean']
+        info = st.session_state['info']
 
     st.subheader("Финальный датасет (первые строки)")
     st.dataframe(df_clean.head(10))
@@ -815,3 +841,1046 @@ if st.session_state.get('preprocessed'):
             except Exception:
                 st.info(
                     'PDF-конверсия недоступна (pdfkit/wkhtmltopdf не установлены). Скачайте HTML и конвертируйте локально, если нужно.')
+
+
+# ---------------- Функция для отображения ЛР №2 ----------------
+def render_lab2():
+    if not LAB2_AVAILABLE:
+        st.error("Функции ЛР №2 недоступны. Убедитесь, что файл lab2_functions.py существует и все зависимости установлены.")
+        return
+    
+    st.title("🧪 Лабораторная работа №2: Прогнозирование временных рядов")
+    st.markdown("**Этапы:** Стратегии прогнозирования, валидация и модели экспоненциального сглаживания")
+    
+    st.markdown("""
+    ---
+    ## 📖 Что происходит в этой работе?
+    
+    **Цель:** Научиться строить модели для прогнозирования будущих значений временного ряда.
+    
+    **Простыми словами:**
+    1. У вас есть данные за прошлое (например, продажи за последние 2 года)
+    2. Вы хотите предсказать, что будет в будущем (например, продажи на следующий месяц)
+    3. Для этого мы строим модели, которые "учатся" на прошлых данных и делают прогнозы
+    
+    **Этапы работы:**
+    - **Этап 1:** Разбираем ряд на части (тренд, сезонность, остатки)
+    - **Этап 2:** Создаём дополнительные признаки (день недели, лаги и т.д.)
+    - **Этап 3:** Выбираем стратегию прогнозирования
+    - **Этап 4:** Проверяем качество моделей через кросс-валидацию
+    - **Этап 5:** Приводим данные к стационарному виду (убираем тренд)
+    - **Этап 6-7:** Строим модели и сравниваем их
+    - **Этап 8:** Анализируем результаты и выбираем лучшую модель
+    
+    **Как работать:**
+    1. Начните с Этапа 1 - выполните декомпозицию
+    2. Перейдите к Этапу 5 - настройте преобразования (можно оставить по умолчанию)
+    3. В Этапе 6-7 нажмите кнопку "Применить преобразования и построить модели"
+    4. Посмотрите результаты в Этапе 8
+    
+    ---
+    """)
+    
+    # Проверка наличия данных из ЛР №1
+    if 'df_clean' not in st.session_state or st.session_state['df_clean'] is None:
+        st.warning("⚠️ Сначала выполните предобработку данных в ЛР №1 или загрузите готовый датасет.")
+        uploaded_file = st.file_uploader("Загрузите предобработанный CSV/Parquet", type=['csv', 'parquet'], key='lab2_upload')
+        if uploaded_file is not None:
+            try:
+                if uploaded_file.name.endswith('.parquet'):
+                    df_clean = pd.read_parquet(uploaded_file)
+                else:
+                    df_clean = pd.read_csv(uploaded_file, low_memory=False)
+                if 'timestamp' not in df_clean.columns:
+                    st.error("В датасете должна быть колонка 'timestamp'")
+                    return
+                df_clean['timestamp'] = pd.to_datetime(df_clean['timestamp'])
+                st.session_state['df_clean'] = df_clean
+                st.success(f"Загружен файл: {uploaded_file.name}")
+            except Exception as e:
+                st.error(f"Ошибка загрузки: {e}")
+                return
+        else:
+            st.stop()
+    
+    df_clean = st.session_state['df_clean'].copy()
+    numeric_cols = df_clean.select_dtypes(include=[np.number]).columns.tolist()
+    
+    if len(numeric_cols) == 0:
+        st.error("Нет числовых колонок для анализа")
+        return
+    
+    # Выбор целевой переменной
+    st.sidebar.header("Параметры прогнозирования")
+    target_col = st.sidebar.selectbox("Целевая переменная", options=numeric_cols, index=0)
+    horizon = st.sidebar.number_input("Горизонт прогнозирования (h)", min_value=1, max_value=365, value=7, step=1)
+    
+    # Разделение на train/test
+    st.header("Этап 1: Углублённая декомпозиция и анализ остатков")
+    
+    if len(df_clean) < 500:
+        st.warning(f"⚠️ Рекомендуется не менее 500 наблюдений для обучения. У вас {len(df_clean)}")
+    
+    train_size = st.sidebar.number_input("Размер обучающей выборки", min_value=100, max_value=len(df_clean)-50, value=min(500, len(df_clean)-50))
+    test_size = len(df_clean) - train_size
+    
+    if test_size < 50:
+        st.error(f"Тестовая выборка слишком мала ({test_size}). Уменьшите размер обучающей выборки.")
+        return
+    
+    df_clean = df_clean.sort_values('timestamp').reset_index(drop=True)
+    train_data = df_clean.iloc[:train_size]
+    test_data = df_clean.iloc[train_size:]
+    
+    st.info(f"Обучающая выборка: {len(train_data)} наблюдений ({train_data['timestamp'].min()} - {train_data['timestamp'].max()})")
+    st.info(f"Тестовая выборка: {len(test_data)} наблюдений ({test_data['timestamp'].min()} - {test_data['timestamp'].max()})")
+    
+    # Декомпозиция
+    with st.expander("Этап 1: Декомпозиция и анализ остатков", expanded=True):
+        decomp_model = st.selectbox("Модель декомпозиции", options=['additive', 'multiplicative'], index=0, key='decomp_model')
+        decomp_period = st.number_input("Период сезонности", min_value=2, max_value=365, value=7, key='decomp_period')
+        
+        if st.button("Выполнить декомпозицию", key='btn_decomp'):
+            s_train = train_data.set_index('timestamp')[target_col].dropna()
+            if len(s_train) < decomp_period * 2:
+                st.error(f"Недостаточно данных для декомпозиции (нужно >= {decomp_period * 2}, есть {len(s_train)})")
+            else:
+                try:
+                    decomp = seasonal_decompose(s_train, period=int(decomp_period), model=decomp_model, extrapolate_trend='freq')
+                    st.session_state['decomp'] = decomp
+                    st.session_state['saved_decomp_period'] = int(decomp_period)  # Сохраняем период для использования в моделях (используем другой ключ, чтобы не конфликтовать с виджетом)
+                    
+                    comp_df = pd.DataFrame({
+                        'timestamp': s_train.index,
+                        'observed': decomp.observed,
+                        'trend': decomp.trend,
+                        'seasonal': decomp.seasonal,
+                        'resid': decomp.resid
+                    })
+                    st.session_state['decomp_df'] = comp_df
+                    
+                    st.subheader("Графики компонентов декомпозиции")
+                    col1, col2 = st.columns(2)
+                    with col1:
+                        st.plotly_chart(px.line(comp_df, x='timestamp', y='observed', title='Observed'), use_container_width=True)
+                        st.plotly_chart(px.line(comp_df, x='timestamp', y='trend', title='Trend'), use_container_width=True)
+                    with col2:
+                        st.plotly_chart(px.line(comp_df, x='timestamp', y='seasonal', title='Seasonal'), use_container_width=True)
+                        st.plotly_chart(px.line(comp_df, x='timestamp', y='resid', title='Residuals'), use_container_width=True)
+                    
+                    # Анализ остатков
+                    resid = comp_df['resid'].dropna()
+                    if len(resid) > 3:
+                        st.subheader("Анализ остатков декомпозиции")
+                        adf_r = run_adf(resid)
+                        kpss_r = run_kpss(resid)
+                        col1, col2 = st.columns(2)
+                        with col1:
+                            st.write("**ADF (остатки):**", adf_r)
+                        with col2:
+                            st.write("**KPSS (остатки):**", kpss_r)
+                        
+                        # ACF/PACF остатков
+                        try:
+                            acf_vals, acf_conf, pacf_vals, pacf_conf = get_acf_pacf_with_conf(resid, nlags=min(40, len(resid)//4), alpha=0.05)
+                            fig_acf, fig_pacf = plotly_acf_pacf(acf_vals, acf_conf, pacf_vals, pacf_conf, max_lag=min(40, len(resid)//4), title_prefix='Residuals')
+                            st.plotly_chart(fig_acf, use_container_width=True)
+                            st.plotly_chart(fig_pacf, use_container_width=True)
+                        except Exception as e:
+                            st.warning(f"Не удалось построить ACF/PACF остатков: {e}")
+                    
+                    st.success("Декомпозиция выполнена")
+                except Exception as e:
+                    st.error(f"Ошибка декомпозиции: {e}")
+    
+    # Этап 2: Feature Engineering
+    with st.expander("Этап 2: Расширенный feature engineering", expanded=False):
+        if st.button("Создать расширенные признаки", key='btn_features'):
+            df_features = create_advanced_features(train_data, target_col, timestamp_col='timestamp')
+            st.session_state['df_features'] = df_features
+            st.success(f"Создано признаков: {len(df_features.columns)}")
+            st.dataframe(df_features.head(10))
+            st.download_button("Скачать датасет с признаками", data=df_features.to_csv(index=False).encode('utf-8'), file_name='dataset_with_features.csv', mime='text/csv')
+    
+    # Этап 3: Стратегии прогнозирования
+    st.header("Этап 3: Стратегии многопшагового прогнозирования")
+    
+    # Этап 4: Кросс-валидация
+    with st.expander("Этап 4: Кросс-валидация для временных рядов", expanded=False):
+        cv_method = st.selectbox("Метод кросс-валидации", options=['sliding_window', 'expanding_window', 'TimeSeriesSplit'], index=0)
+        cv_train_size = st.number_input("Размер обучающей выборки для CV", min_value=50, max_value=train_size, value=min(300, train_size), key='cv_train_size')
+        cv_test_size = st.number_input("Размер тестовой выборки для CV", min_value=10, max_value=100, value=30, key='cv_test_size')
+        cv_step = st.number_input("Шаг для CV", min_value=1, max_value=50, value=10, key='cv_step')
+        
+        if st.button("Выполнить кросс-валидацию", key='btn_cv'):
+            s_full = df_clean.set_index('timestamp')[target_col].dropna()
+            
+            # Функция-обёртка для создания модели
+            def create_model_wrapper(data, **kwargs):
+                return create_exponential_smoothing_model(data, trend='add', seasonal=None, optimized=True)
+            
+            try:
+                if cv_method == 'sliding_window':
+                    cv_results = time_series_cv_sliding_window(
+                        create_model_wrapper, s_full, train_size=cv_train_size, 
+                        test_size=cv_test_size, horizon=horizon, step=cv_step
+                    )
+                elif cv_method == 'expanding_window':
+                    cv_results = time_series_cv_expanding_window(
+                        create_model_wrapper, s_full, initial_train_size=cv_train_size,
+                        test_size=cv_test_size, horizon=horizon, step=cv_step
+                    )
+                else:  # TimeSeriesSplit
+                    from sklearn.model_selection import TimeSeriesSplit
+                    tscv = TimeSeriesSplit(n_splits=min(5, (len(s_full) - cv_train_size) // cv_test_size))
+                    cv_results = []
+                    for fold, (train_idx, test_idx) in enumerate(tscv.split(s_full), 1):
+                        train_cv = s_full.iloc[train_idx]
+                        test_cv = s_full.iloc[test_idx]
+                        try:
+                            model = create_model_wrapper(train_cv)
+                            forecast = model.forecast(steps=min(horizon, len(test_cv)))
+                            metrics = evaluate_forecast(test_cv.values[:len(forecast)], forecast)
+                            metrics['fold'] = fold
+                            cv_results.append(metrics)
+                        except Exception as e:
+                            st.warning(f"Ошибка в фолде {fold}: {e}")
+                
+                if cv_results:
+                    cv_df = pd.DataFrame(cv_results)
+                    st.subheader("Результаты кросс-валидации")
+                    st.dataframe(cv_df)
+                    
+                    # Средние метрики
+                    st.subheader("Средние метрики по фолдам")
+                    avg_metrics = cv_df[['MAE', 'RMSE', 'MAPE']].mean()
+                    st.dataframe(avg_metrics.to_frame('Среднее значение'))
+                    
+                    # Визуализация метрик по фолдам
+                    fig_cv = go.Figure()
+                    fig_cv.add_trace(go.Scatter(x=cv_df['fold'], y=cv_df['MAE'], name='MAE', mode='lines+markers'))
+                    fig_cv.add_trace(go.Scatter(x=cv_df['fold'], y=cv_df['RMSE'], name='RMSE', mode='lines+markers'))
+                    fig_cv.update_layout(title='Метрики по фолдам кросс-валидации', xaxis_title='Фолд', yaxis_title='Значение метрики')
+                    st.plotly_chart(fig_cv, use_container_width=True)
+                    
+                    st.session_state['cv_results'] = cv_results
+            except Exception as e:
+                st.error(f"Ошибка кросс-валидации: {e}")
+                import traceback
+                st.code(traceback.format_exc())
+    
+    # Этап 5: Преобразования к стационарности
+    st.header("📊 Этап 5: Приведение к стационарности и преобразования")
+    st.markdown("""
+    **Что это значит?** 
+    
+    Временные ряды часто имеют тренд (растут или падают) и меняющуюся дисперсию. 
+    Многие модели требуют стационарных данных (без тренда, с постоянной дисперсией).
+    
+    **Что нужно сделать:**
+    1. Выберите тип преобразования (или оставьте 'none' для начала)
+    2. Если нужно, укажите порядок дифференцирования (обычно 1)
+    3. Нажмите кнопку "Применить преобразования и построить модели" в следующем разделе
+    """)
+    
+    with st.expander("⚙️ Настройки преобразований", expanded=True):
+        transform_type = st.selectbox(
+            "Тип преобразования", 
+            options=['none', 'log', 'boxcox'], 
+            index=0, 
+            key='transform_type',
+            help="none = без преобразования, log = логарифм (для стабилизации дисперсии), boxcox = автоматический подбор преобразования"
+        )
+        lambda_param = None
+        if transform_type == 'boxcox':
+            lambda_param = st.number_input(
+                "Lambda для Бокса-Кокса (0 = авто)", 
+                min_value=-5.0, max_value=5.0, value=0.0, step=0.1, 
+                key='lambda_param',
+                help="Оставьте 0 для автоматического подбора оптимального значения"
+            )
+            if lambda_param == 0.0:
+                lambda_param = None
+        
+        diff_order = st.number_input(
+            "Порядок дифференцирования", 
+            min_value=0, max_value=3, value=0, 
+            key='diff_order',
+            help="0 = без дифференцирования, 1 = первая разность (убирает тренд), 2 = вторая разность"
+        )
+        seasonal_diff = st.number_input(
+            "Сезонное дифференцирование (период, 0 = отключено)", 
+            min_value=0, max_value=365, value=0, 
+            key='seasonal_diff',
+            help="Укажите период сезонности (например, 7 для недельной, 30 для месячной). 0 = отключено"
+        )
+        
+        st.info("""
+        💡 **Рекомендации для улучшения прогноза:**
+        
+        1. **Если наивный прогноз лучше моделей:**
+           - Попробуйте добавить сезонность: выберите модели Holt-Winters и укажите период сезонности
+           - Используйте период из декомпозиции (Этап 1)
+           - Попробуйте diff_order=1 для устранения тренда
+           - Попробуйте преобразование Бокса-Кокса для стабилизации дисперсии
+        
+        2. **Для данных с сезонностью:**
+           - Обязательно используйте модели Holt-Winters
+           - Период сезонности должен совпадать с периодом из декомпозиции
+        
+        3. **Для данных с трендом:**
+           - Используйте diff_order=1
+           - Или выберите модели с трендом (Holt_add, Holt_mul)
+        
+        4. **Начните с простого:** 'none' и diff_order=0, затем постепенно добавляйте сложность
+        """)
+    
+    # Этап 6-7: Модели и стратегии
+    st.header("🔮 Этап 6-7: Модели экспоненциального сглаживания и стратегии прогнозирования")
+    st.markdown("""
+    **Что здесь происходит?**
+    
+    Здесь мы строим модели для прогнозирования будущих значений временного ряда.
+    
+    **Стратегии прогнозирования:**
+    - **recursive (рекурсивная):** Одна модель, которая использует свои предыдущие прогнозы
+    - **direct (прямая):** Отдельная модель для каждого шага вперёд
+    - **hybrid (гибридная):** Комбинация рекурсивной и прямой
+    
+    **Модели:**
+    - **SES:** Простое экспоненциальное сглаживание (без тренда и сезонности)
+    - **Holt_add:** Модель Хольта с аддитивным трендом (линейный рост/падение, без сезонности)
+    - **Holt_mul:** Модель Хольта с мультипликативным трендом (экспоненциальный рост/падение, без сезонности)
+    - **Holt-Winters_add:** Модель Хольта-Винтерса с аддитивным трендом и сезонностью (рекомендуется для данных с сезонностью!)
+    - **Holt-Winters_mul:** Модель Хольта-Винтерса с мультипликативным трендом и сезонностью
+    """)
+    
+    strategy_choice = st.multiselect(
+        "Выберите стратегии прогнозирования",
+        options=['recursive', 'direct', 'hybrid'],
+        default=['recursive'],
+        key='strategy_choice',
+        help="Можно выбрать несколько для сравнения"
+    )
+    
+    model_types = st.multiselect(
+        "Выберите модели",
+        options=['SES', 'Holt_add', 'Holt_mul', 'Holt-Winters_add', 'Holt-Winters_mul'],
+        default=['Holt_add', 'Holt-Winters_add'],
+        key='model_types',
+        help="Можно выбрать несколько для сравнения. Holt-Winters учитывает сезонность."
+    )
+    
+    # Настройка сезонности для моделей Holt-Winters
+    use_seasonal = any('Holt-Winters' in m for m in model_types)
+    seasonal_period = None
+    
+    # Пытаемся автоматически определить период из декомпозиции
+    default_seasonal_period = 7
+    if 'saved_decomp_period' in st.session_state:
+        default_seasonal_period = st.session_state.get('saved_decomp_period', 7)
+    elif 'decomp' in st.session_state:
+        # Пытаемся извлечь период из декомпозиции
+        try:
+            decomp = st.session_state.get('decomp')
+            if hasattr(decomp, 'seasonal') and len(decomp.seasonal) > 0:
+                # Пытаемся определить период по длине сезонной компоненты
+                seasonal_len = len(decomp.seasonal.dropna())
+                # Округляем до ближайшего разумного значения
+                if 6 <= seasonal_len <= 8:
+                    default_seasonal_period = 7
+                elif 28 <= seasonal_len <= 32:
+                    default_seasonal_period = 30
+                elif 360 <= seasonal_len <= 370:
+                    default_seasonal_period = 365
+                else:
+                    default_seasonal_period = min(seasonal_len, 365)
+        except:
+            pass
+    
+    if use_seasonal:
+        seasonal_period = st.number_input(
+            "Период сезонности для моделей Holt-Winters",
+            min_value=2,
+            max_value=365,
+            value=int(default_seasonal_period),
+            key='seasonal_period',
+            help=f"Используйте период из декомпозиции (например, 7 для недельной, 30 для месячной). Автоопределено: {default_seasonal_period}"
+        )
+        if 'saved_decomp_period' in st.session_state:
+            st.info(f"💡 Подсказка: В декомпозиции использовался период {st.session_state.get('saved_decomp_period')}. Рекомендуется использовать тот же пери��д.")
+    
+    # Настройка доверительных интервалов
+    use_conf_int = st.sidebar.checkbox("Показать доверительные интервалы", value=False, key='use_conf_int')
+    conf_alpha = st.sidebar.slider("Уровень значимости для доверительных интервалов", min_value=0.01, max_value=0.5, value=0.05, step=0.01, key='conf_alpha') if use_conf_int else None
+    
+    if st.button("Применить преобразования и построить модели", key='btn_models'):
+        s_train = train_data.set_index('timestamp')[target_col].dropna()
+        s_test = test_data.set_index('timestamp')[target_col].dropna()
+        
+        # Сохраняем исходные данные для обратного преобразования
+        s_train_original = s_train.copy()
+        s_test_original = s_test.copy()
+        
+        # Применяем преобразования
+        try:
+            # Проверяем наличие неположительных значений для log и boxcox
+            has_nonpositive = (s_train <= 0).any()
+            negative_count = (s_train <= 0).sum() if has_nonpositive else 0
+            min_value = float(s_train.min())
+            max_value = float(s_train.max())
+            
+            # АВТОМАТИЧЕСКИЙ СДВИГ - если есть неположительные значения и нужен log/boxcox
+            if (transform_type == 'log' or transform_type == 'boxcox') and has_nonpositive:
+                shift_value = abs(min_value) + 1  # Сдвигаем так, чтобы минимум стал 1
+                
+                # Автоматически применяем сдвиг БЕЗ ВСЯКИХ КНОПОК
+                s_train = s_train + shift_value
+                s_test = s_test + shift_value
+                s_train_original = s_train_original + shift_value
+                s_test_original = s_test_original + shift_value
+                
+                st.info(f"✅ Автоматически применен сдвиг: +{shift_value:.2f} (было {negative_count} нулевых значений)")
+            
+            s_train_transformed, transform_info = apply_transformations(
+                s_train, transformation=transform_type, lambda_param=lambda_param,
+                diff_order=diff_order, seasonal_diff=seasonal_diff if seasonal_diff > 0 else None
+            )
+            
+            st.info(f"Применено преобразование: {transform_info}")
+            
+            # Проверка стационарности после преобразования
+            st.subheader("Проверка стационарности после преобразования")
+            adf_res = run_adf(s_train_transformed)
+            kpss_res = run_kpss(s_train_transformed)
+            col1, col2 = st.columns(2)
+            with col1:
+                st.write("**ADF:**", adf_res)
+            with col2:
+                st.write("**KPSS:**", kpss_res)
+            
+            # Модели экспоненциального сглаживания
+            st.subheader("Результаты моделей")
+            
+            all_results = []
+            all_forecasts = {}
+            all_forecasts_transformed = {}  # Прогнозы в преобразованном пространстве
+            all_conf_intervals = {}  # Доверительные интервалы
+            all_models = {}
+            
+            # Функция-обёртка для стратегий
+            def create_ses_model(data):
+                return create_exponential_smoothing_model(data, trend=None, seasonal=None, optimized=True)
+            
+            def create_holt_add_model(data):
+                return create_exponential_smoothing_model(data, trend='add', seasonal=None, optimized=True)
+            
+            def create_holt_mul_model(data):
+                return create_exponential_smoothing_model(data, trend='mul', seasonal=None, optimized=True)
+            
+            def create_hw_add_model(data):
+                return create_exponential_smoothing_model(
+                    data, 
+                    trend='add', 
+                    seasonal='add', 
+                    seasonal_periods=seasonal_period if seasonal_period and seasonal_period > 1 else None,
+                    optimized=True
+                )
+            
+            def create_hw_mul_model(data):
+                return create_exponential_smoothing_model(
+                    data, 
+                    trend='mul', 
+                    seasonal='mul', 
+                    seasonal_periods=seasonal_period if seasonal_period and seasonal_period > 1 else None,
+                    optimized=True
+                )
+            
+            for model_name in model_types:
+                if model_name == 'SES':
+                    model_func = create_ses_model
+                    model_display = 'SES'
+                elif model_name == 'Holt_add':
+                    model_func = create_holt_add_model
+                    model_display = 'Holt (additive)'
+                elif model_name == 'Holt_mul':
+                    if not (s_train_transformed > 0).all():
+                        st.warning("Holt multiplicative требует положительные значения - пропущено")
+                        continue
+                    model_func = create_holt_mul_model
+                    model_display = 'Holt (multiplicative)'
+                elif model_name == 'Holt-Winters_add':
+                    if seasonal_period is None or seasonal_period < 2:
+                        st.warning(f"Holt-Winters требует период сезонности >= 2. Пропущено {model_name}")
+                        continue
+                    if len(s_train_transformed) < seasonal_period * 2:
+                        st.warning(f"Holt-Winters требует минимум {seasonal_period * 2} наблюдений. У вас {len(s_train_transformed)}. Пропущено {model_name}")
+                        continue
+                    model_func = create_hw_add_model
+                    model_display = f'Holt-Winters (additive, period={seasonal_period})'
+                elif model_name == 'Holt-Winters_mul':
+                    if not (s_train_transformed > 0).all():
+                        st.warning("Holt-Winters multiplicative требует положительные значения - пропущено")
+                        continue
+                    if seasonal_period is None or seasonal_period < 2:
+                        st.warning(f"Holt-Winters требует период сезонности >= 2. Пропущено {model_name}")
+                        continue
+                    if len(s_train_transformed) < seasonal_period * 2:
+                        st.warning(f"Holt-Winters требует минимум {seasonal_period * 2} наблюдений. У вас {len(s_train_transformed)}. Пропущено {model_name}")
+                        continue
+                    model_func = create_hw_mul_model
+                    model_display = f'Holt-Winters (multiplicative, period={seasonal_period})'
+                else:
+                    continue
+                
+                for strategy in strategy_choice:
+                    try:
+                        alpha_param = conf_alpha if use_conf_int else None
+                        if strategy == 'recursive':
+                            forecast_result = recursive_forecast(model_func, s_train_transformed, horizon=min(horizon, len(s_test)), alpha=alpha_param)
+                        elif strategy == 'direct':
+                            forecast_result = direct_forecast(model_func, s_train_transformed, horizon=min(horizon, len(s_test)), alpha=alpha_param)
+                        elif strategy == 'hybrid':
+                            forecast_result = hybrid_forecast(model_func, s_train_transformed, horizon=min(horizon, len(s_test)), alpha=alpha_param)
+                        else:
+                            continue
+                        
+                        # Извлекаем прогноз и доверительные интервалы
+                        # Функции возвращают либо (forecast, None), либо (forecast, (lower, upper))
+                        if isinstance(forecast_result, tuple) and len(forecast_result) == 2:
+                            forecast_transformed, conf_int = forecast_result
+                            # Если conf_int это кортеж из двух массивов, оставляем как есть
+                            # Если это None, оставляем None
+                        else:
+                            # Если функция вернула просто массив (старый формат)
+                            forecast_transformed = forecast_result
+                            conf_int = None
+                        
+                        # Применяем обратное преобразование к прогнозу
+                        if transform_info.get('transformation') != 'none' or diff_order > 0 or (seasonal_diff and seasonal_diff > 0):
+                            # Для обратного преобразования нужны последние значения преобразованного ряда
+                            # Промежуточные значения уже сохранены в transform_info
+                            last_train_vals_transformed = s_train_transformed.values
+                            
+                            forecast = inverse_transformations(
+                                forecast_transformed,
+                                last_train_vals_transformed,
+                                transform_info
+                            )
+                            
+                            # Применяем обратное преобразование к доверительным интервалам, если они есть
+                            if conf_int is not None:
+                                conf_lower_transformed = conf_int[0]
+                                conf_upper_transformed = conf_int[1]
+                                conf_lower = inverse_transformations(
+                                    conf_lower_transformed,
+                                    last_train_vals_transformed,
+                                    transform_info
+                                )
+                                conf_upper = inverse_transformations(
+                                    conf_upper_transformed,
+                                    last_train_vals_transformed,
+                                    transform_info
+                                )
+                                conf_int = (conf_lower, conf_upper)
+                        else:
+                            forecast = forecast_transformed
+                        
+                        # Оцениваем метрики в исходных единицах
+                        test_values = s_test_original.values[:len(forecast)]
+                        metrics = evaluate_forecast(test_values, forecast)
+                        metrics['model'] = model_display
+                        metrics['strategy'] = strategy
+                        all_results.append(metrics)
+                        all_forecasts[f"{model_display}_{strategy}"] = forecast
+                        all_forecasts_transformed[f"{model_display}_{strategy}"] = forecast_transformed
+                        if conf_int is not None:
+                            all_conf_intervals[f"{model_display}_{strategy}"] = conf_int
+                        
+                        # Сохраняем модель для диагностики
+                        fitted_model = model_func(s_train_transformed)
+                        all_models[f"{model_display}_{strategy}"] = fitted_model
+                        
+                    except Exception as e:
+                        st.warning(f"{model_display} ({strategy}): {e}")
+                        import traceback
+                        st.code(traceback.format_exc())
+            
+            # Наивный прогноз (в исходных единицах)
+            naive_pred = naive_forecast(s_train_original, min(horizon, len(s_test)))
+            naive_metrics = evaluate_forecast(s_test_original.values[:len(naive_pred)], naive_pred)
+            naive_metrics['model'] = 'Naive'
+            naive_metrics['strategy'] = 'naive'
+            all_results.append(naive_metrics)
+            all_forecasts['Naive'] = naive_pred
+            
+            # Сравнение моделей
+            if all_results:
+                st.subheader("Сравнение моделей и стратегий")
+                results_df = pd.DataFrame(all_results)
+                results_pivot = results_df.pivot_table(
+                    values=['MAE', 'RMSE', 'MAPE'],
+                    index='model',
+                    columns='strategy',
+                    aggfunc='first'
+                )
+                st.dataframe(results_pivot)
+                
+                # Визуализация прогнозов - показываем весь ряд с прогнозами
+                fig = go.Figure()
+                
+                # 1. Обучающая выборка (исторические данные)
+                fig.add_trace(go.Scatter(
+                    x=s_train_original.index,
+                    y=s_train_original.values,
+                    name='Исторические данные (train)',
+                    line=dict(color='#1f77b4', width=2),
+                    mode='lines'
+                ))
+                
+                # 2. Тестовая выборка (фактические значения)
+                test_len = min(horizon, len(s_test_original))
+                fig.add_trace(go.Scatter(
+                    x=s_test_original.index[:test_len],
+                    y=s_test_original.values[:test_len],
+                    name='Фактические значения (test)',
+                    line=dict(color='black', width=3),
+                    mode='lines'
+                ))
+                
+                # 3. Прогнозы от каждой модели
+                colors = px.colors.qualitative.Set3
+                color_idx = 0
+                
+                for name, forecast in all_forecasts.items():
+                    if name == 'Naive':
+                        continue  # Наивный прогноз обработаем отдельно
+                    
+                    color = colors[color_idx % len(colors)]
+                    
+                    # Создаём индекс�� для прогноза (продолжение после обучающей выборки)
+                    if len(forecast) > 0:
+                        # Определяем частоту временного ряда
+                        try:
+                            freq = pd.infer_freq(s_train_original.index) or pd.infer_freq(s_test_original.index) or 'D'
+                            # Создаём даты для прогноза - используем pd.date_range напрямую
+                            last_train_date = s_train_original.index[-1]
+                            # Создаём даты начиная с последней даты + 1 период
+                            # Используем periods=len(forecast)+1 и берём все кроме первого
+                            forecast_dates = pd.date_range(
+                                start=last_train_date,
+                                periods=len(forecast) + 1,
+                                freq=freq
+                            )[1:]  # Берём все даты кроме первой (которая равна last_train_date)
+                        except Exception as e:
+                            # Если не удалось определить частоту, используем индексы тестовой выборки
+                            try:
+                                forecast_dates = s_test_original.index[:len(forecast)]
+                            except:
+                                # Последний вариант - создаем простой числовой индекс
+                                forecast_dates = range(len(s_train_original), len(s_train_original) + len(forecast))
+                        
+                        # Добавляем доверительные интервалы, если они есть
+                        if name in all_conf_intervals:
+                            conf_lower, conf_upper = all_conf_intervals[name]
+                            
+                            # Преобразуем hex цвет в RGB для rgba
+                            try:
+                                if color.startswith('#'):
+                                    r = int(color[1:3], 16)
+                                    g = int(color[3:5], 16)
+                                    b = int(color[5:7], 16)
+                                else:
+                                    r, g, b = 100, 100, 100
+                                fillcolor = f'rgba({r}, {g}, {b}, 0.15)'
+                            except:
+                                fillcolor = 'rgba(100, 100, 100, 0.15)'
+                            
+                            # Верхняя граница доверительного интервала
+                            fig.add_trace(go.Scatter(
+                                x=forecast_dates,
+                                y=conf_upper,
+                                mode='lines',
+                                line=dict(width=0),
+                                showlegend=False,
+                                hoverinfo='skip',
+                                name=f'{name} CI upper'
+                            ))
+                            
+                            # Нижняя граница с заливкой
+                            fig.add_trace(go.Scatter(
+                                x=forecast_dates,
+                                y=conf_lower,
+                                mode='lines',
+                                line=dict(width=0),
+                                fill='tonexty',
+                                fillcolor=fillcolor,
+                                name=f'{name} (доверительный интервал)',
+                                showlegend=True,
+                                legendgroup=name
+                            ))
+                        
+                        # Линия прогноза
+                        fig.add_trace(go.Scatter(
+                            x=forecast_dates,
+                            y=forecast,
+                            name=f'{name} (прогноз)',
+                            line=dict(dash='dash', color=color, width=2.5),
+                            mode='lines',
+                            legendgroup=name
+                        ))
+                    
+                    color_idx += 1
+                
+                # Наивный прогноз (если есть)
+                if 'Naive' in all_forecasts:
+                    naive_forecast_vals = all_forecasts['Naive']
+                    try:
+                        freq = pd.infer_freq(s_train_original.index) or pd.infer_freq(s_test_original.index) or 'D'
+                        last_train_date = s_train_original.index[-1]
+                        # Создаём даты начиная с последней даты + 1 период
+                        naive_dates = pd.date_range(
+                            start=last_train_date,
+                            periods=len(naive_forecast_vals) + 1,
+                            freq=freq
+                        )[1:]  # Берём все даты кроме первой
+                    except Exception as e:
+                        try:
+                            naive_dates = s_test_original.index[:len(naive_forecast_vals)]
+                        except:
+                            naive_dates = range(len(s_train_original), len(s_train_original) + len(naive_forecast_vals))
+                    
+                    fig.add_trace(go.Scatter(
+                        x=naive_dates,
+                        y=naive_forecast_vals,
+                        name='Naive (прогноз)',
+                        line=dict(dash='dot', color='gray', width=2),
+                        mode='lines'
+                    ))
+                
+                # Вертикальная линия, разделяющая train и test
+                if len(s_train_original) > 0:
+                    split_date = s_train_original.index[-1]
+                    # Преобразуем Timestamp в строку для plotly
+                    if isinstance(split_date, pd.Timestamp):
+                        split_date_str = split_date.strftime('%Y-%m-%d %H:%M:%S')
+                    else:
+                        split_date_str = str(split_date)
+                    
+                    # Используем add_shape вместо add_vline для лучшей совместимости
+                    fig.add_shape(
+                        type="line",
+                        x0=split_date,
+                        x1=split_date,
+                        y0=0,
+                        y1=1,
+                        yref="paper",
+                        line=dict(dash="dot", color="red", width=1)
+                    )
+                    # Добавляем аннотацию отдельно
+                    fig.add_annotation(
+                        x=split_date,
+                        y=1,
+                        yref="paper",
+                        text="Разделение train/test",
+                        showarrow=False,
+                        xanchor="center",
+                        yanchor="bottom",
+                        bgcolor="rgba(255,255,255,0.8)",
+                        bordercolor="red",
+                        borderwidth=1
+                    )
+                
+                fig.update_layout(
+                    title=f'Прогнозирование временного ряда (horizon={horizon})',
+                    height=600,
+                    xaxis_title='Дата',
+                    yaxis_title='Значение',
+                    hovermode='x unified',
+                    legend=dict(
+                        orientation="v",
+                        yanchor="top",
+                        y=1,
+                        xanchor="left",
+                        x=1.02
+                    ),
+                    template='plotly_white'
+                )
+                st.plotly_chart(fig, use_container_width=True)
+                
+                # Экспорт прогнозов
+                st.subheader("Экспорт прогнозов")
+                export_model = st.selectbox("Выберите модель для экспорта", options=list(all_forecasts.keys()), key='export_model')
+                if export_model in all_forecasts:
+                    forecast_export = all_forecasts[export_model]
+                    # Создаём DataFrame с прогнозами
+                    forecast_dates = pd.date_range(
+                        start=s_test_original.index[0],
+                        periods=len(forecast_export),
+                        freq=pd.infer_freq(s_test_original.index) or 'D'
+                    )
+                    forecast_df = pd.DataFrame({
+                        'date': forecast_dates,
+                        'forecast': forecast_export,
+                        'actual': s_test_original.values[:len(forecast_export)] if len(s_test_original) >= len(forecast_export) else None
+                    })
+                    forecast_csv = forecast_df.to_csv(index=False).encode('utf-8')
+                    st.download_button(
+                        f"Скачать прогноз ({export_model})",
+                        data=forecast_csv,
+                        file_name=f'forecast_{export_model.replace(" ", "_")}.csv',
+                        mime='text/csv'
+                    )
+                    
+                    # Экспорт параметров модели
+                    if export_model in all_models:
+                        model = all_models[export_model]
+                        params_dict = {
+                            'model': export_model,
+                            'horizon': horizon,
+                            'transformation': transform_info.get('transformation', 'none'),
+                            'lambda': transform_info.get('lambda', None),
+                            'diff_order': transform_info.get('diff_order', 0),
+                            'seasonal_diff': transform_info.get('seasonal_diff', None),
+                        }
+                        # Добавляем параметры модели, если доступны
+                        if hasattr(model, 'params'):
+                            params_dict['model_params'] = str(model.params)
+                        if hasattr(model, 'aic'):
+                            params_dict['aic'] = model.aic
+                        if hasattr(model, 'bic'):
+                            params_dict['bic'] = model.bic
+                        
+                        params_df = pd.DataFrame([params_dict])
+                        params_csv = params_df.to_csv(index=False).encode('utf-8')
+                        st.download_button(
+                            f"Скачать параметры модели ({export_model})",
+                            data=params_csv,
+                            file_name=f'model_params_{export_model.replace(" ", "_")}.csv',
+                            mime='text/csv'
+                        )
+                
+                # Сохраняем результаты в session
+                st.session_state['forecast_results'] = all_results
+                st.session_state['forecasts'] = all_forecasts
+                st.session_state['forecasts_transformed'] = all_forecasts_transformed
+                st.session_state['models'] = all_models
+                st.session_state['s_train_transformed'] = s_train_transformed
+                st.session_state['s_train_original'] = s_train_original
+                st.session_state['s_test'] = s_test_original
+                st.session_state['transform_info'] = transform_info
+            
+        except Exception as e:
+            st.error(f"❌ Ошибка при построении моделей: {e}")
+            st.info("""
+            **Возможные причины ошибки:**
+            1. Недостаточно данных для обучения модели
+            2. Проблемы с преобразованиями (например, отрицательные значения при логарифме)
+            3. Несовместимость параметров модели с данными
+            
+            **Что попробовать:**
+            - Уменьшите размер обучающей выборки
+            - Измените параметры преобразований (попробуйте 'none' и diff_order=0)
+            - Попробуйте другую модель (например, только SES)
+            """)
+            import traceback
+            with st.expander("🔍 Детали ошибки (для отладки)"):
+                st.code(traceback.format_exc())
+    
+    # Этап 7: Диагностика остатков
+    st.header("Этап 7: Диагностика адекватности моделей")
+    
+    if 'models' in st.session_state and st.session_state['models']:
+        model_for_diagnosis = st.selectbox(
+            "Выберите модель для диагностики",
+            options=list(st.session_state['models'].keys()),
+            key='model_diagnosis'
+        )
+        
+        if st.button("Выполнить диагностику остатков", key='btn_diagnosis'):
+            try:
+                model = st.session_state['models'][model_for_diagnosis]
+                s_train_transformed = st.session_state['s_train_transformed']
+                
+                # Получаем остатки
+                fitted_values = model.fittedvalues
+                residuals = s_train_transformed - fitted_values
+                residuals = residuals.dropna()
+                
+                if len(residuals) > 3:
+                    # Диагностика
+                    diagnosis = diagnose_model_residuals(residuals.values, lags=min(20, len(residuals)//4))
+                    
+                    st.subheader("Результаты диагностики остатков")
+                    
+                    # Тест Льюнга-Бокса
+                    if 'ljung_box' in diagnosis:
+                        lb = diagnosis['ljung_box']
+                        if 'pvalue' in lb:
+                            st.write(f"**Тест Льюнга-Бокса:**")
+                            st.write(f"- Статистика: {lb.get('statistic', 'N/A'):.4f}")
+                            st.write(f"- p-value: {lb.get('pvalue', 'N/A'):.4f}")
+                            if lb.get('pvalue', 1) < 0.05:
+                                st.warning("Остатки имеют автокорреляцию (p < 0.05)")
+                            else:
+                                st.success("Остатки не имеют значимой автокорреляции (p >= 0.05)")
+                    
+                    # Тест нормальности
+                    if 'shapiro_wilk' in diagnosis:
+                        sw = diagnosis['shapiro_wilk']
+                        st.write(f"**Тест Шапиро-Уилка (нормальность):**")
+                        st.write(f"- Статистика: {sw.get('statistic', 'N/A'):.4f}")
+                        st.write(f"- p-value: {sw.get('pvalue', 'N/A'):.4f}")
+                        if sw.get('pvalue', 0) < 0.05:
+                            st.warning("Остатки не распределены нормально (p < 0.05)")
+                        else:
+                            st.success("Остатки распределены нормально (p >= 0.05)")
+                    elif 'normality_test' in diagnosis:
+                        nt = diagnosis['normality_test']
+                        st.write(f"**Тест нормальности ({nt.get('test', 'N/A')}):**")
+                        st.write(f"- Статистика: {nt.get('statistic', 'N/A'):.4f}")
+                        st.write(f"- p-value: {nt.get('pvalue', 'N/A'):.4f}")
+                    
+                    # Стационарность остатков
+                    if 'stationarity' in diagnosis:
+                        st.write(f"**Стационарность остатков:**")
+                        stn = diagnosis['stationarity']
+                        if 'adf' in stn:
+                            st.write(f"- ADF p-value: {stn['adf'].get('pvalue', 'N/A'):.4f}")
+                        if 'kpss' in stn:
+                            st.write(f"- KPSS p-value: {stn['kpss'].get('pvalue', 'N/A'):.4f}")
+                    
+                    # Статистики остатков
+                    if 'residual_stats' in diagnosis:
+                        rs = diagnosis['residual_stats']
+                        st.write(f"**Статистики остатков:**")
+                        st.write(f"- Среднее: {rs.get('mean', 'N/A'):.6f}")
+                        st.write(f"- Стд. отклонение: {rs.get('std', 'N/A'):.6f}")
+                        st.write(f"- Min: {rs.get('min', 'N/A'):.4f}, Max: {rs.get('max', 'N/A'):.4f}")
+                    
+                    # Визуализация остатков
+                    st.subheader("Визуализация остатков")
+                    
+                    col1, col2 = st.columns(2)
+                    
+                    with col1:
+                        # График остатков vs прогнозов (гомоскедастичность)
+                        fig_resid = go.Figure()
+                        fig_resid.add_trace(go.Scatter(
+                            x=fitted_values.values,
+                            y=residuals.values,
+                            mode='markers',
+                            name='Остатки'
+                        ))
+                        fig_resid.add_hline(y=0, line_dash="dash", line_color="red")
+                        fig_resid.update_layout(
+                            title='Остатки vs Прогнозы (гомоскедастичность)',
+                            xaxis_title='Прогноз',
+                            yaxis_title='Остаток'
+                        )
+                        st.plotly_chart(fig_resid, use_container_width=True)
+                        
+                        # Гистограмма остатков
+                        fig_hist = px.histogram(
+                            x=residuals.values,
+                            nbins=30,
+                            title='Распределение остатков'
+                        )
+                        st.plotly_chart(fig_hist, use_container_width=True)
+                    
+                    with col2:
+                        # Q-Q plot
+                        qq_data = scipy_stats.probplot(residuals.values, dist="norm")
+                        fig_qq = go.Figure()
+                        fig_qq.add_trace(go.Scatter(
+                            x=qq_data[0][0],
+                            y=qq_data[0][1],
+                            mode='markers',
+                            name='Остатки'
+                        ))
+                        fig_qq.add_trace(go.Scatter(
+                            x=qq_data[0][0],
+                            y=qq_data[1][1] + qq_data[1][0] * qq_data[0][0],
+                            mode='lines',
+                            name='Теоретическая линия',
+                            line=dict(color='red', dash='dash')
+                        ))
+                        fig_qq.update_layout(
+                            title='Q-Q Plot (нормальность)',
+                            xaxis_title='Теоретические квантили',
+                            yaxis_title='Выборочные квантили'
+                        )
+                        st.plotly_chart(fig_qq, use_container_width=True)
+                        
+                        # Временной ряд остатков
+                        fig_time = px.line(
+                            x=residuals.index,
+                            y=residuals.values,
+                            title='Временной ряд остатков'
+                        )
+                        fig_time.add_hline(y=0, line_dash="dash", line_color="red")
+                        st.plotly_chart(fig_time, use_container_width=True)
+                    
+            except Exception as e:
+                st.error(f"Ошибка диагностики: {e}")
+                import traceback
+                st.code(traceback.format_exc())
+    else:
+        st.info("Сначала постройте модели, чтобы выполнить диагностику остатков")
+    
+    # Этап 8: Выводы и рекомендации
+    st.header("📈 Этап 8: Сравнительный анализ и выводы")
+    st.markdown("""
+    **Что здесь происходит?**
+    
+    В этом разделе вы видите итоговые результаты всех построенных моделей и можете сравнить их качество.
+    
+    **Что означают метрики:**
+    - **MAE (Mean Absolute Error):** Средняя абсолютная ошибка. Чем меньше, тем лучше.
+    - **RMSE (Root Mean Squared Error):** Корень из средней квадратичной ошибки. Чем меньше, тем лучше. Более чувствительна к большим ошибкам.
+    - **MAPE (Mean Absolute Percentage Error):** Средняя абсолютная процентная ошибка. Показывает ошибку в процентах. Чем меньше, тем лучше.
+    
+    **Что нужно сделать:**
+    1. Посмотрите на таблицу метрик - какая модель и стратегия показали лучшие результаты?
+    2. Обратите внимание на рекомендации ниже
+    3. Используйте эту информацию для выбора лучшей модели для ваших данных
+    """)
+    
+    if 'forecast_results' in st.session_state:
+        st.subheader("📊 Итоговая таблица метрик")
+        final_df = pd.DataFrame(st.session_state['forecast_results'])
+        st.dataframe(final_df.set_index(['model', 'strategy']))
+        
+        # Лучшая модель по каждой метрике
+        st.subheader("🏆 Лучшие модели по метрикам")
+        for metric in ['MAE', 'RMSE', 'MAPE']:
+            if metric in final_df.columns:
+                best_idx = final_df[metric].idxmin()
+                best = final_df.loc[best_idx]
+                st.write(f"**{metric}:** {best['model']} ({best['strategy']}) = {best[metric]:.4f}")
+        
+        st.subheader("💡 Рекомендации")
+        st.info("""
+        **Общие рекомендации:**
+        - **Короткий горизонт (h < 7):** Рекурсивная стратегия обычно работает лучше
+        - **Длинный горизонт (h >= 30):** Прямая или гибридная стратегия могут быть предпочтительнее
+        - **Преобразование Бокса-Кокса:** Используйте, если дисперсия нестабильна
+        - **Дифференцирование:** Применяйте, если ряд нестационарен (попробуйте diff_order=1)
+        - **Диагностика остатков:** Убедитесь, что остатки не имеют автокорреляции и распределены нормально
+        
+        **Как выбрать модель:**
+        1. Посмотрите, какая модель имеет наименьшие MAE, RMSE и MAPE
+        2. Проверьте диагностику остатков для этой модели (Этап 7)
+        3. Если остатки имеют проблемы, попробуйте другую модель или добавьте преобразования
+        """)
+    else:
+        st.warning("⚠️ Сначала постройте модели в разделе 'Этап 6-7', чтобы увидеть результаты сравнения.")
+
+
+# ---------------- Главный код: выбор лабораторной работы ----------------
+if lab_choice == "ЛР №1: Введение в анализ временных рядов":
+    render_lab1()
+elif lab_choice == "ЛР №2: Прогнозирование временных рядов":
+    render_lab2()
+else:
+    st.info("Выберите лабораторную работу в боковой панели")

БЫСТРЫЙ_СТАРТ.md

@@ -0,0 +1,197 @@
+# ⚡ Быстрый старт
+
+## 🚀 Запуск программы
+
+```bash
+pip install -r requirements.txt
+streamlit run src/streamlit_app.py
+```
+
+Откройте браузер: `http://localhost:8501`
+
+---
+
+## 📋 ЛР №1: Пошаговая инструкция
+
+### Шаг 1: Загрузка данных
+- Загрузите CSV файл или выберите пример
+- Укажите колонку с датами
+
+### Шаг 2: Предобработка
+- Нажмите **"Run Preprocessing"**
+- Оставьте настройки по умолчанию (или измените при необходимости)
+
+### Шаг 3: Статистика
+- Посмотрите таблицу дескриптивной статистики
+- Изучите гистограммы и матрицу корреляций
+
+### Шаг 4: Стационарность
+- Выберите целевую переменную
+- Нажмите **"Run stationarity tests"**
+- Если нестационарен → нажмите **"Apply diff & Re-test"** с `diff_order=1`
+
+### Шаг 5: Лаги
+- Укажите лаги: `1,7,30`
+- Укажите окна: `7,30`
+- Нажмите **"Generate lags & rolls"**
+
+### Шаг 6: ACF/PACF
+- Выберите целевую переменную
+- Установите `max_lag=40`
+- Посмотрите графики и значимые лаги
+
+### Шаг 7: Декомпозиция
+- Выберите модель: `additive`
+- Укажите период: `7` (для недельной) или `30` (для месячной)
+- Нажмите **"Run decomposition"**
+
+### Шаг 8: Отчёт
+- Нажмите **"Сгенерировать и показать отчёт"**
+- Скачайте HTML-отчёт
+
+---
+
+## 🔮 ЛР №2: Пошаговая инструкция
+
+### Шаг 1: Подготовка
+- Убедитесь, что данные из ЛР №1 загружены
+- Выберите целевую переменную
+- Установите горизонт прогнозирования (h): `7` или `30`
+
+### Шаг 2: Декомпозиция
+- Выберите период сезонности: `7` или `30`
+- Нажмите **"Выполнить декомпозицию"**
+
+### Шаг 3: Преобразования (опционально)
+- Начните с `none` и `diff_order=0`
+- Если модель плохая → попробуйте `diff_order=1`
+
+### Шаг 4: Модели
+- Выберите стратегии: `recursive` (для начала)
+- Выберите модели: `SES`, `Holt_add`
+- Нажмите **"Применить преобразования и построить модели"**
+
+### Шаг 5: Результаты
+- Посмотрите таблицу метрик
+- Найдите модель с наименьшими MAE, RMSE, MAPE
+- Посмотрите график прогнозов
+
+### Шаг 6: Диагностика
+- Выберите лучшую модель
+- Нажмите **"Выполнить диагностику остатков"**
+- Проверьте, что p-value тестов > 0.05
+
+### Шаг 7: Выводы
+- Посмотрите итоговую таблицу
+- Выберите лучшую модель
+- Скачайте прогнозы и параметры модели
+
+---
+
+## 📊 Что означают метрики
+
+| Метрика | Что означает | Чем меньше, тем лучше |
+|---------|-------------|------------------------|
+| **MAE** | Средняя абсолютная ошибка | ✅ |
+| **RMSE** | Корень из средней квадратичной ошибки | ✅ |
+| **MAPE** | Средняя абсолютная процентная ошибка (%) | ✅ |
+
+**Пример:** MAPE = 10% означает, что в среднем ошибка 10%
+
+---
+
+## 🎯 Тесты стационарности
+
+| Тест | Стационарен если | Нестационарен если |
+|------|------------------|---------------------|
+| **ADF** | p-value < 0.05 ✅ | p-value >= 0.05 ❌ |
+| **KPSS** | p-value > 0.05 ✅ | p-value <= 0.05 ❌ |
+
+**Если нестационарен:** примените `diff_order=1`
+
+---
+
+## 🔍 Корреляции
+
+| Значение | Интерпретация |
+|----------|---------------|
+| **1.0** | Полная прямая связь |
+| **0.7-1.0** | Сильная связь |
+| **0.3-0.7** | Умеренная связь |
+| **0.0-0.3** | Слабая связь |
+| **0.0** | Нет связи |
+| **-1.0** | Полная обратная связь |
+
+**Проблема:** Если два признака коррелируют > 0.8 → мультиколлинеарность
+
+---
+
+## 🎨 Модели экспоненциального сглаживания
+
+| Модель | Когда использовать |
+|--------|-------------------|
+| **SES** | Стационарный ряд без тренда |
+| **Holt Additive** | Ряд с линейным трендом |
+| **Holt Multiplicative** | Ряд с экспоненциальным трендом |
+
+---
+
+## 🚦 Стратегии прогнозирования
+
+| Стратегия | Когда использовать |
+|-----------|-------------------|
+| **Recursive** | Короткий горизонт (h < 7) |
+| **Direct** | Длинный горизонт (h >= 30) |
+| **Hybrid** | Средний горизонт (7-30) |
+
+---
+
+## ⚠️ Частые ошибки
+
+1. **"Недостаточно данных"**
+   - Решение: уменьшите размер обучающей выборки
+
+2. **"Для лог-трансформации все значения должны быть положительными"**
+   - **Причина:** В данных есть нули или отрицательные значения
+   - **Решения:**
+     - ✅ **Используйте Box-Cox** вместо логарифма (автоматически обработает проблему)
+     - ✅ **Используйте только дифференцирование** (diff_order=1) без логарифма
+     - ✅ **Включите автоматический сдвиг** - программа предложит сдвинуть данные
+   - **Как исправить:**
+     1. Посмотрите статистику данных в сообщении об ошибке
+     2. Включите чекбокс "Автоматически сдвинуть данные"
+     3. Или измените тип преобразования на "boxcox"
+
+3. **"Ошибка при преобразовании"**
+   - Решение: убедитесь, что все значения положительные (для log/boxcox)
+
+4. **"Модель работает плохо"**
+   - Решение: попробуйте `diff_order=1` или другую модель
+
+5. **"Остатки имеют автокорреляцию"**
+   - Решение: попробуйте другую модель или стратегию
+
+---
+
+## 💡 Советы
+
+1. ✅ Начинайте с простого (SES, recursive, без преобразований)
+2. ✅ Сравнивайте с наивным прогнозом (baseline)
+3. ✅ Проверяйте диагностику остатков
+4. ✅ Экспериментируйте с разными моделями
+5. ✅ Сохраняйте результаты (CSV, HTML-отчёты)
+
+---
+
+## 📁 Что скачивать
+
+- **final_dataset.csv** - очищенные данные (ЛР №1)
+- **dataset_with_lags.csv** - данные с лагами (ЛР №1)
+- **ts_report.html** - HTML-отчёт (ЛР №1)
+- **forecast_*.csv** - прогнозы моделей (ЛР №2)
+- **model_params_*.csv** - параметры моделей (ЛР №2)
+
+---
+
+**Подробное руководство:** см. `РУКОВОДСТВО.md`
+

РУКОВОДСТВО.md

@@ -0,0 +1,655 @@
+# 📚 Руководство по использованию программы для анализа временных рядов
+
+## 🎯 Общая структура проекта
+
+Ваш проект состоит из двух лабораторных работ, объединённых в одно веб-приложение:
+
+### Файлы проекта:
+- **`src/streamlit_app.py`** - главный файл веб-приложения (1655 строк)
+- **`src/lab2_functions.py`** - функции для лабораторной работы №2 (604 строки)
+- **`src/main.py`** - не используется (можно игнорировать)
+- **`russia_covid_dataset.csv`** - пример данных (COVID-19 по России)
+
+---
+
+## 🚀 Как запустить программу
+
+1. **Установите зависимости:**
+   ```bash
+   pip install -r requirements.txt
+   ```
+
+2. **Запустите приложение:**
+   ```bash
+   streamlit run src/streamlit_app.py
+   ```
+
+3. **Откройте браузер:**
+   - Программа автоматически откроется на `http://localhost:8501`
+   - Или откройте вручную этот адрес
+
+---
+
+## 📖 ЛАБОРАТОРНАЯ РАБОТА №1: Введение в анализ временных рядов
+
+### Что делает эта работа?
+
+Эта работа учит вас **"читать"** временной ряд - понимать его структуру, находить закономерности, выявлять проблемы.
+
+### Порядок работы (по этапам):
+
+#### **Этап 1: Загрузка данных**
+1. В боковой панели нажмите "Загрузите CSV/Parquet"
+2. Или выберите предзагруженный пример (если есть `russia_covid_dataset.csv`)
+3. Укажите колонку с датами (программа попытается найти её автоматически)
+
+**Что происходит:** Программа загружает ваш файл и показывает первые строки.
+
+---
+
+#### **Этап 2: Предобработка данных (Preprocessing)**
+
+**Настройки в боковой панели:**
+- **Как трактовать tz-naive метки?** - как обрабатывать даты без временной зоны
+- **Заполнение пропусков (числ.)** - что делать с пропущенными числами:
+  - `interpolate` - заполнить интерполяцией (рекомендуется)
+  - `drop` - удалить строки
+  - `rolling` - заполнить скользящим средним
+- **Обработка выбросов** - что делать с аномальными значениями:
+  - `interpolate` - заменить интерполяцией
+  - `winsorize` - обрезать экстремальные значения
+  - `drop` - удалить
+  - `mark` - только отметить
+- **Ресемплить к частоте** - изменить частоту данных (D=день, W=неделя, M=месяц)
+
+**Что делать:**
+1. Нажмите кнопку **"Run Preprocessing"**
+2. Программа покажет:
+   - Сколько строк было до/после обработки
+   - Сколько пропусков найдено и обработано
+   - Сколько выбросов обнаружено
+
+**Результат:** Очищенный датасет, готовый к анализу.
+
+---
+
+#### **Этап 3: Описательная статистика и визуализация**
+
+**Что показывается:**
+
+1. **Таблица дескриптивной статистики:**
+   - `count` - количество наблюдений
+   - `mean` - среднее значение
+   - `median` - медиана (середина)
+   - `std` - стандартное отклонение (разброс)
+   - `min/max` - минимум/максимум
+   - `q1/q3` - первый и третий квартили (25% и 75%)
+   - `skew` - асимметрия (если >0, хвост справа)
+   - `kurtosis` - эксцесс (острота распределения)
+
+2. **Гистограммы и Boxplot:**
+   - **Гистограмма** - показывает распределение значений (как часто встречается каждое значение)
+   - **Boxplot** - показывает медиану, квартили и выбросы
+
+3. **Матрица корреляций:**
+   - Показывает, насколько связаны между собой признаки
+   - Значения от -1 до 1:
+     - **1** = полная прямая связь
+     - **0** = нет связи
+     - **-1** = полная ��братная связь
+   - **Важно:** Если два признака сильно коррелируют (>0.8), это может быть проблемой (мультиколлинеарность)
+
+**Как интерпретировать:**
+- Если `std` большой относительно `mean` - данные сильно разбросаны
+- Если `skew` далёк от 0 - распределение несимметрично
+- Сильные корреляции (>0.7) указывают на зависимость признаков
+
+---
+
+#### **Этап 4: Проверка на стационарность**
+
+**Что такое стационарность?**
+Стационарный ряд = ряд без тренда, с постоянной дисперсией. Многие модели требуют стационарности.
+
+**Что показывается:**
+
+1. **График ряда с rolling mean:**
+   - Если линия скользящего среднего не горизонтальна → есть тренд (нестационарен)
+   - Если линия скользящего среднего горизонтальна → тренда нет (стационарен)
+
+2. **График rolling std:**
+   - Если линия не горизонтальна → дисперсия меняется (нестационарен)
+   - Если горизонтальна → дисперсия постоянна
+
+3. **Статистические тесты:**
+   - **ADF (Augmented Dickey-Fuller):**
+     - p-value < 0.05 → ряд стационарен ✅
+     - p-value >= 0.05 → ряд нестационарен ❌
+   - **KPSS:**
+     - p-value > 0.05 → ряд стационарен ✅
+     - p-value <= 0.05 → ряд нестационарен ❌
+
+**Что делать, если ряд нестационарен:**
+1. Нажмите "Apply diff & Re-test" с `diff_order=1`
+2. Это применит дифференцирование (убирает тренд)
+3. Повторите тесты
+
+---
+
+#### **Этап 5: Создание лагов и скользящих статистик**
+
+**Что такое лаги?**
+Лаг = значение переменной в прошлом. Например, `target_lag_7` = значение target 7 дней назад.
+
+**Что создаётся:**
+- **Лаги:** `target_lag_1`, `target_lag_7`, `target_lag_30`
+- **Скользящие статистики:**
+  - `target_rolling_mean_7` - среднее за последние 7 дней
+  - `target_rolling_std_7` - стандартное отклонение за последние 7 дней
+
+**Как использовать:**
+1. Укажите целевую переменную (target)
+2. Укажите лаги через запятую (например: `1,7,30`)
+3. Укажите окна для скользящих (например: `7,30`)
+4. Нажмите "Generate lags & rolls"
+
+**Что показывается:**
+- Таблица корреляций лагов с target - какие лаги наиболее информативны
+- Heatmap корреляций - визуализация всех корреляций
+- VIF (Variance Inflation Factor) - проверка мультиколлинеарности:
+  - VIF < 5 → нормально
+  - VIF 5-10 → умеренная мультиколлинеарность
+  - VIF > 10 → сильная мультиколлинеарность (проблема)
+
+---
+
+#### **Этап 6: ACF и PACF**
+
+**Что это такое?**
+- **ACF (Autocorrelation Function)** - корреляция ряда с его лагами
+- **PACF (Partial Autocorrelation Function)** - "чистая" корреляция с лагом
+
+**Как интерпретировать графики:**
+
+1. **ACF:**
+   - Плавное затухание → возможный порядок MA(q)
+   - Резкий обрыв → возможный порядок AR(p)
+
+2. **PACF:**
+   - Резкий обрыв на лаге p → возможный порядок AR(p)
+   - Плавное затухание → возможный порядок MA(q)
+
+3. **Значимые лаги:**
+   - Лаги, выходящие за доверительный интервал (синие линии) → статистически значимы
+   - Эти лаги важны для моделирования
+
+**Что делать:**
+- Посмотрите, какие лаги значимы
+- Запомните порядок обрыва в PACF - это может быть порядок AR модели
+
+---
+
+#### **Этап 7: Декомпозиция временного ряда**
+
+**Что такое декомпозиция?**
+Разложение ряда на компоненты:
+- **Observed** - исходный ряд
+- **Trend** - тренд (долгосрочная тенденция)
+- **Seasonal** - сезонность (периодические колебания)
+- **Residual** - остатки (случайные колебания)
+
+**Модели декомпозиции:**
+- **Additive (аддитивная):** `value = trend + seasonal + residual`
+  - Используйте, если амплитуда сезонности постоянна
+- **Multiplicative (мультипликативная):** `value = trend × seasonal × residual`
+  - Используйте, если амплитуда сезонности растёт со временем
+
+**Как использовать:**
+1. Выберите целевую переменную
+2. Выберите модель (additive/multiplicative)
+3. Укажите период сезонности:
+   - 7 - для недельной сезонности
+   - 30 - для месячной
+   - 365 - для годовой
+4. Нажмите "Run decomposition"
+
+**Что показывается:**
+- Графики всех компонентов
+- Анализ тренда (растёт/падает)
+- Амплитуда сезонности
+- Диагностика остатков (должны быть стационарны и случайны)
+
+**Как интерпретировать:**
+- Если остатки стационарны (ADF/KPSS тесты) → декомпозиция хорошая ✅
+- Если остатки нестационарны → попробуйте другой период или модель ❌
+
+---
+
+#### **Этап 8: Генерация отчёта**
+
+**Что делает:**
+Собирает все графики и таблицы в один HTML-отчёт.
+
+**Как использовать:**
+1. Настройте параметры в разделе "Параметры для отчёта"
+2. Нажмите "Сгенерировать и показать отчёт"
+3. Просмотрите результаты во вкладках
+4. Скачайте HTML-отчёт
+
+---
+
+## 🔮 ЛАБОРАТОРНАЯ РАБОТА №2: Прогнозирование временных рядов
+
+### Что делает эта работа?
+
+Эта работа учит строить **модели для прогнозирования** будущих значений временного ряда.
+
+### Порядок работы:
+
+#### **Этап 1: Декомпозиция и анализ остатков**
+
+**Что делать:**
+1. Убедитесь, что данные из ЛР №1 загружены
+2. Выберите целевую переменную в боковой панели
+3. Укажите горизонт прогнозирования (h) - на сколько шагов вперёд прогнозировать
+4. Настройте размер обучающей выборки (рекомендуется ≥500)
+5. Нажмите "Выполнить декомпозицию"
+
+**Что показывается:**
+- Графики компонентов (observed, trend, seasonal, residuals)
+- Анализ остатков (должны быть стационарны)
+- ACF/PACF остатков (не должно быть значимых лагов)
+
+**Как интерпретировать:**
+- Если остатки стационарны и не имеют автокорреляции → декомпозиция хорошая ✅
+- Если нет → попробуйте другой период или модель
+
+---
+
+#### **Этап 2: Feature Engineering**
+
+**Что создаётся:**
+- Временные признаки (день недели, месяц, квартал)
+- Циклические признаки (sin/cos для периодичности)
+- Лаги (lag_1, lag_7, lag_30)
+- Скользящие статистики (mean, std, min, max)
+
+**Как использовать:**
+1. Нажмите "Создать расширенные признаки"
+2. Просмотрите созданные признаки
+3. Скачайте датасет с признаками (опционально)
+
+---
+
+#### **Этап 3: Стратегии прогнозирования**
+
+**Три стратегии:**
+
+1. **Recursive (рекурсивная):**
+   - Одна модель
+   - Использует свои предыдущие прогнозы
+   - ✅ Хорошо для короткого горизонта (h < 7)
+   - ❌ Ошибка накапливается на длинном горизонте
+
+2. **Direct (прямая):**
+   - Отдельная модель для каждого шага
+   - Прогнозы независимы
+   - ✅ Хорошо для длинного горизонта (h >= 30)
+   - ❌ Требует больше вычислений
+
+3. **Hybrid (гибридная):**
+   - Комбинация: рекурсивная для ближних шагов, прямая для дальних
+   - ✅ Баланс ме��ду точностью и скоростью
+
+**Как использовать:**
+- Выберите стратегии в разделе "Этап 6-7"
+- Можно выбрать несколько для сравнения
+
+---
+
+#### **Этап 4: Кросс-валидация**
+
+**Что такое кросс-валидация?**
+Проверка качества модели на разных частях данных без утечки будущего.
+
+**Методы:**
+1. **Sliding window (скользящее окно):**
+   - Фиксированная длина обучения
+   - Окно "скользит" по времени
+
+2. **Expanding window (расширяющееся окно):**
+   - Длина обучения растёт
+   - Более реалистично для реальных задач
+
+3. **TimeSeriesSplit:**
+   - Стандартный метод из sklearn
+   - Прогрессивное разбиение
+
+**Как использовать:**
+1. Выберите метод
+2. Настройте размеры train/test
+3. Нажмите "Выполнить кросс-валидацию"
+
+**Что показывается:**
+- Таблица метрик по фолдам
+- Средние метрики
+- График метрик по фолдам
+
+**Как интерпретировать:**
+- Если метрики стабильны по фолдам → модель надёжна ✅
+- Если метрики сильно меняются → модель нестабильна ❌
+
+---
+
+#### **Этап 5: Преобразования к стационарности**
+
+**Зачем нужно?**
+Многие модели требуют стационарных данных.
+
+**Типы преобразований:**
+
+1. **None (без преобразования):**
+   - Используйте, если данные уже стационарны
+
+2. **Log (логарифм):**
+   - Стабилизирует дисперсию
+   - Требует положительные значения
+   - Используйте, если дисперсия растёт со временем
+
+3. **Box-Cox:**
+   - Автоматический подбор преобразования
+   - Включает логарифм как частный случай
+   - ✅ Рекомендуется, если не уверены
+
+4. **Дифференцирование:**
+   - `diff_order=1` - убирает тренд (первая разность)
+   - `diff_order=2` - убирает квадратичный тренд
+   - `seasonal_diff=7` - убирает сезонность (для недельной)
+
+**Как использовать:**
+1. Начните с `none` и `diff_order=0`
+2. Если модель плохая, попробуйте `diff_order=1`
+3. Если дисперсия нестабильна, попробуйте `log` или `boxcox`
+
+**Что показывается:**
+- Результаты тестов ADF/KPSS после преобразования
+- Если p-value ADF < 0.05 и p-value KPSS > 0.05 → стационарен ✅
+
+---
+
+#### **Этап 6-7: Модели экспоненциального сглаживания**
+
+**Три модели:**
+
+1. **SES (Simple Exponential Smoothing):**
+   - Простое сглаживание без тренда
+   - ✅ Хорошо для стационарных рядов
+   - ❌ Не учитывает тренд
+
+2. **Holt Additive:**
+   - С аддитивным трендом (линейный рост/падение)
+   - ✅ Хорошо для рядов с линейным трендом
+   - Формула: `level + trend`
+
+3. **Holt Multiplicative:**
+   - С мультипликативным трендом (экспоненциальный рост/падение)
+   - ✅ Хорошо для рядов с экспоненциальным трендом
+   - ❌ Требует положительные значения
+   - Формула: `level × trend`
+
+**Как использовать:**
+1. Выберите стратегии прогнозирования
+2. Выберите модели (можно несколько)
+3. Нажмите "Применить преобразования и построить модели"
+
+**Что показывается:**
+- Таблица сравнения метрик (MAE, RMSE, MAPE)
+- График прогнозов всех моделей
+- Сравнение с наивным прогнозом (baseline)
+
+**Метрики качества:**
+
+1. **MAE (Mean Absolute Error):**
+   - Средняя абсолютная ошибка
+   - Чем меньше, тем лучше
+   - Интерпретация: среднее отклонение прогноза от реальности
+
+2. **RMSE (Root Mean Squared Error):**
+   - Корень из средней квадратичной ошибки
+   - Чем меньше, те�� лучше
+   - Более чувствительна к большим ошибкам
+   - Интерпретация: типичное отклонение (с учётом больших ошибок)
+
+3. **MAPE (Mean Absolute Percentage Error):**
+   - Средняя абсолютная процентная ошибка
+   - Чем меньше, тем лучше
+   - Интерпретация: ошибка в процентах
+   - Пример: MAPE=5% означает, что в среднем ошибка 5%
+
+**Как интерпретировать:**
+- Сравните метрики моделей
+- Выберите модель с наименьшими MAE, RMSE, MAPE
+- Убедитесь, что модель лучше наивного прогноза
+
+---
+
+#### **Этап 7: Диагностика остатков**
+
+**Что проверяется:**
+
+1. **Тест Льюнга-Бокса:**
+   - Проверяет автокорреляцию в остатках
+   - p-value < 0.05 → есть автокорреляция (плохо) ❌
+   - p-value >= 0.05 → нет автокорреляции (хорошо) ✅
+
+2. **Тест Шапиро-Уилка:**
+   - Проверяет нормальность распределения остатков
+   - p-value < 0.05 → не нормально (плохо) ❌
+   - p-value >= 0.05 → нормально (хорошо) ✅
+
+3. **Графики:**
+   - **Остатки vs Прогнозы:** должны быть случайными (гомоскедастичность)
+   - **Q-Q Plot:** точки должны лежать на прямой (нормальность)
+   - **Временной ряд остатков:** не должно быть тренда
+
+**Как использовать:**
+1. Выберите модель для диагностики
+2. Нажмите "Выполнить диагностику остатков"
+
+**Как интерпретировать:**
+- Если все тесты пройдены → модель адекватна ✅
+- Если есть проблемы → попробуйте другую модель или добавьте преобразования
+
+---
+
+#### **Этап 8: Сравнительный анализ и выводы**
+
+**Что показывается:**
+- Итоговая таблица метрик всех моделей
+- Лучшие модели по каждой метрике
+- Рекомендации по выбору модели
+
+**Как использовать:**
+1. Посмотрите на таблицу метрик
+2. Найдите модель с наименьшими ошибками
+3. Проверьте диагностику остатков для этой модели
+4. Используйте эту модель для прогнозирования
+
+**Рекомендации:**
+- **Короткий горизонт (h < 7):** рекурсивная стратегия
+- **Длинный горизонт (h >= 30):** прямая или гибридная стратегия
+- **Нестационарный ряд:** используйте дифференцирование (diff_order=1)
+- **Нестабильная дисперсия:** используйте Box-Cox преобразование
+
+---
+
+## 📊 Что означают числа и метрики
+
+### Статистические метрики:
+
+- **Mean (среднее):** среднее значение всех наблюдений
+- **Median (медиана):** значение в середине (50% наблюдений меньше)
+- **Std (стандартное отклонение):** мера разброса данных
+  - Маленькое std → данные сконцентрированы
+  - Большое std → данные разбросаны
+- **Min/Max:** минимальное и максимальное значения
+- **Q1/Q3 (квартили):** 25% и 75% наблюдений меньше этого значения
+- **Skew (асимметрия):**
+  - 0 = симметричное распределение
+  - >0 = хвост справа (больше больших значений)
+  - <0 = хвост слева (больше маленьких значений)
+- **Kurtosis (эксцесс):**
+  - 0 = нормальное распределение
+  - >0 = более острое распределение (больше экстремальных значений)
+  - <0 = более плоское распределение
+
+### Метрики качества прогноза:
+
+- **MAE:** средняя абсолютная ошибка (в тех же единицах, что и данные)
+- **RMSE:** корень из средней квадратичной ошибки (более чувствительна к большим ошибкам)
+- **MAPE:** средняя абсолютная процентная ошибка (в процентах)
+
+**Пример интерпретации:**
+- Если MAPE = 10%, это означает, что в среднем прогноз отклоняется на 10% от реальности
+- Если MAE = 100, это означает, что в среднем прогноз отклоняется на 100 единиц
+
+### Тесты стационарности:
+
+- **ADF p-value:**
+  - < 0.05 → ряд стационарен ✅
+  - >= 0.05 → ряд нестационарен ❌
+- **KPSS p-value:**
+  - > 0.05 → ряд стационарен ✅
+  - <= 0.05 → ряд нестационарен ❌
+
+### Корреляции:
+
+- **1.0:** полная прямая связь (когда один растёт, другой тоже растёт)
+- **0.0:** нет связи
+- **-1.0:** полная обратная связь (когда один растёт, другой падает)
+- **0.7-1.0:** сильная связь
+- **0.3-0.7:** умеренная связь
+- **0.0-0.3:** слабая связь
+
+---
+
+## 🎓 Типичный workflow (порядок работы)
+
+### Для ЛР №1:
+
+1. Загрузите данные
+2. Запустите предобработку
+3. Посмотрите описательную статистику
+4. Проверьте стационарность
+5. Создайте лаги и скользящие статистики
+6. Постройте ACF/PACF
+7. Выполните декомпозицию
+8. Сгенерируйте отчёт
+
+### Для ЛР №2:
+
+1. Убедитесь, что данные из ЛР №1 загружены
+2. Выполните декомпозицию
+3. (Опционально) Создайте расширенные признаки
+4. (Опционально) Выполните кросс-валидацию
+5. Настройте преобразования (начните с none, diff_order=0)
+6. Постройте модели (выберите несколько для сравнения)
+7. Проверьте диагностику остатков для лучшей модели
+8. Посмотрите итоговые результаты и выберите лучшую модель
+
+---
+
+## ⚠️ Частые проблемы и решения
+
+### Проблема: "Недостаточно данных"
+**Решение:** Уменьшите размер обучающей выборки или увеличьте тестовую
+
+### Проблема: "Для лог-трансформации все значения должны быть положительными"
+**Причина:** 
+Логарифм можно применять только к положительным числам. Если в данных есть нули или отрицательные значения, логарифм не может быть вычислен.
+
+**Что покажет программа:**
+- Количество неположительных значений
+- Минимальное и максимальное значения
+- График распределения данных
+- Предложение автоматического сдвига
+
+**Решения:**
+
+1. **Используйте Box-Cox преобразование** (рекомендуется):
+   - Измените тип преобразования с `log` на `boxcox`
+   - Box-Cox автоматически обработает проблему (требует только положительные значения, но может работать с нулями через сдвиг)
+
+2. **Используйте только дифференцирование**:
+   - Оставьте `transformation='none'`
+   - Установите `diff_order=1`
+   - Это уберёт тренд без необходимости логарифма
+
+3. **Автоматический сдвиг данных**:
+   - Включите чекбокс "Автоматически сдвинуть данные"
+   - Программа добавит константу ко всем значениям, чтобы сделать их положительными
+   - Минимум станет равным 1 (или больше)
+
+4. **Вручную сдвиньте данные** (перед загрузкой):
+   - Если данные содержат отрицательные значения или нули
+   - Добавьте константу ко всем значениям в CSV файле
+   - Например: `new_value = old_value + abs(min_value) + 1`
+
+**Как выбрать решение:**
+- Если данные близки к нулю → используйте Box-Cox
+- Если нужно сохранить интерпретацию → используйте только дифференцирование
+- Если данные уже в логарифмической шкале → проверьте, не применяли ли в�� логарифм дважды
+
+### Проблема: "Ошибка при преобразовании" (общая)
+**Решение:** 
+- Для логарифма: убедитесь, что все значения положительные (см. выше)
+- Для Box-Cox: убедитесь, что все значения положительные (или используйте автоматический сдвиг)
+
+### Проблема: "Модель работает плохо"
+**Решение:**
+1. Попробуйте дифференцирование (diff_order=1)
+2. Попробуйте Box-Cox преобразование
+3. Попробуйте другую модель (например, Holt вместо SES)
+4. Проверьте, стационарен ли ряд
+
+### Проблема: "Остатки имеют автокорреляцию"
+**Решение:**
+1. Попробуйте другую модель
+2. Добавьте больше лагов
+3. Попробуйте другую стратегию прогнозирования
+
+---
+
+## 💡 Советы
+
+1. **Начинайте просто:** сначала попробуйте модель без преобразований
+2. **Сравнивайте с baseline:** убедитесь, что ваша модель лучше наивного прогноза
+3. **Проверяйте диагностику:** хорошая модель должна иметь "хорошие" остатки
+4. **Экспериментируйте:** пробуйте разные комбинации моделей и стратегий
+5. **Документируйте:** записывайте, что пробовали и какие результаты получили
+
+---
+
+## 📝 Что делать с результатами
+
+1. **Сохраните очищенные данные:** скачайте `final_dataset.csv`
+2. **Сохраните прогнозы:** скачайте прогнозы лучшей модели
+3. **Сохраните параметры модели:** скачайте параметры для воспроизведения
+4. **Создайте отчёт:** используйте HTML-отчёт из ЛР №1
+5. **Задокументируйте выводы:** запишите, какая модель лучше и почему
+
+---
+
+## 🎯 Ключевые выводы
+
+- **ЛР №1** учит понимать структуру данных
+- **ЛР №2** учит строить модели для прогнозирования
+- **Метрики** показывают качество модели
+- **Диагностика** проверяет адекватность модели
+- **Преобразования** нужны для стационарности
+- **Стратегии** влияют на качество прогноза
+
+---
+
+**Удачи в работе! 🚀**
+

СТРУКТУРА_КОДА.md

@@ -0,0 +1,334 @@
+# 🏗️ Структура кода проекта
+
+## 📁 Файловая структура
+
+```
+TimeSeriesHomework/
+├── src/
+│   ├── streamlit_app.py      # Главное веб-приложение (1655 строк)
+│   ├── lab2_functions.py      # Функции для ЛР №2 (604 строки)
+│   ├── main.py                # Не используется (можно игнорировать)
+│   └── russia_covid_dataset.csv # Пример данных
+├── requirements.txt           # Зависимости Python
+├── README.md                  # Описание проекта
+├── РУКОВОДСТВО.md            # Подробное руководство (этот файл)
+├── БЫСТРЫЙ_СТАРТ.md          # Краткая шпаргалка
+└── СТРУКТУРА_КОДА.md        # Этот файл
+```
+
+---
+
+## 🔍 streamlit_app.py - Главное приложение
+
+### Структура файла:
+
+```
+1. Импорты (строки 1-34)
+   ├── Библиотеки: pandas, numpy, streamlit, plotly
+   ├── Статистика: statsmodels, scipy
+   └── Импорт функций из lab2_functions.py
+
+2. Утилиты (строки 45-94)
+   ├── detect_date_column() - поиск колонки с датами
+   ├── try_parse_dates() - парсинг дат
+   ├── localize_to_moscow() - приведение к часовому поясу
+   ├── detect_outliers_iqr() - поиск выбросов
+   └── winsorize_series() - обработка выбросов
+
+3. Предобработка (строки 96-195)
+   └── preprocess_timeseries() - основная функция очистки данных
+       ├── Парсинг дат
+       ├── Обработка пропусков
+       ├── Обработка выбросов
+       └── Ресемплирование
+
+4. Описательная статистика (строки 198-217)
+   └── descriptive_statistics() - расчёт статистик
+
+5. Стационарность (строки 220-234)
+   ├── run_adf() - тест Дики-Фуллера
+   └── run_kpss() - тест KPSS
+
+6. Лаги и скользящие (строки 237-274)
+   ├── create_lags_and_rolls() - создание лагов
+   ├── compute_lag_correlations() - корреляции лагов
+   └── compute_vif() - проверка мультиколлинеарности
+
+7. ACF/PACF (строки 277-316)
+   ├── get_acf_pacf_with_conf() - расчёт ACF/PACF
+   ├── significant_lags_from_conf() - значимые лаги
+   └── plotly_acf_pacf() - визуализация
+
+8. Генерация отчёта (строки 319-359)
+   └── generate_html_report() - создание HTML-отчёта
+
+9. Функция ЛР №1 (строки 362-844)
+   └── render_lab1() - весь интерфейс ЛР №1
+       ├── Загрузка данных
+       ├── Предобработка
+       ├── Описательная статистика
+       ├── Стационарность
+       ├── Лаги и скользящие
+       ├── ACF/PACF
+       ├── Декомпозиция
+       └── Генерация отчёта
+
+10. Функция ЛР №2 (строки 846-1646)
+    └── render_lab2() - весь интерфейс ЛР №2
+        ├── Декомпозиция
+        ├── Feature Engineering
+        ├── Кросс-валидация
+        ├── Преобразования
+        ├── Модели экспоненциального сглаживания
+        ├── Диагностика остатков
+        └── Сравнительный анализ
+
+11. Главный код (строки 1648-1654)
+    └── Выбор лабораторной работы через sidebar
+```
+
+### Поток данных в ЛР №1:
+
+```
+Загрузка CSV
+    ↓
+preprocess_timeseries()
+    ↓
+df_clean (очищенные данные)
+    ↓
+descriptive_statistics() → Таблица статистик
+    ↓
+run_adf() / run_kpss() → Тесты стационарности
+    ↓
+create_lags_and_rolls() → Датасет с лагами
+    ↓
+get_acf_pacf_with_conf() → Графики ACF/PACF
+    ↓
+seasonal_decompose() → Декомпозиция
+    ↓
+generate_html_report() → HTML-отчёт
+```
+
+### Поток данных в ЛР №2:
+
+```
+df_clean (из ЛР №1)
+    ↓
+Разделение на train/test
+    ↓
+seasonal_decompose() → Декомпозиция
+    ↓
+create_advanced_features() → Расширенные признаки (опционально)
+    ↓
+apply_transformations() → Преобразования к стационарности
+    ↓
+create_exponential_smoothing_model() → Модель
+    ↓
+recursive_forecast() / direct_forecast() / hybrid_forecast() → Прогноз
+    ↓
+inverse_transformations() → Обратное преобразование
+    ↓
+evaluate_forecast() → Метрики (MAE, RMSE, MAPE)
+    ↓
+diagnose_model_residuals() → Диагностика остатков
+```
+
+---
+
+## 🔧 lab2_functions.py - Функции для ЛР №2
+
+### Структура файла:
+
+```
+1. Метрики (строки 18-25)
+   └── calculate_mape() - расчёт MAPE
+
+2. Feature Engineering (строки 28-70)
+   └── create_advanced_features() - создание признаков
+       ├── Временные признаки (день недели, месяц)
+       ├── Циклические признаки (sin/cos)
+       ├── Лаги (lag_1, lag_7, lag_30)
+       └── Скользящие статистики (mean, std, min, max)
+
+3. Преобразования (строки 73-223)
+   ├── apply_boxcox_transform() - преобразование Бокса-Кокса
+   ├── inverse_boxcox_transform() - обратное преобразование
+   ├── apply_transformations() - цепочка преобразований
+   └── inverse_transformations() - обратная цепочка
+
+4. Стратегии прогнозирования (строки 226-413)
+   ├── recursive_forecast() - рекурсивная стратегия
+   ├── direct_forecast() - прямая стратегия
+   └── hybrid_forecast() - гибридная стратегия
+
+5. Модели (строки 416-435)
+   └── create_exponential_smoothing_model() - создание модели
+
+6. Оценка качества (строки 438-457)
+   ├── evaluate_forecast() - метрики качества
+   └── naive_forecast() - наивный прогноз (baseline)
+
+7. Кросс-валидация (строки 460-535)
+   ├── time_series_cv_sliding_window() - скользящее окно
+   └── time_series_cv_expanding_window() - расширяющееся окно
+
+8. Диагностика (строки 538-602)
+   └── diagnose_model_residuals() - диагностика остатков
+       ├── Тест Льюнга-Бокса (автокорреляция)
+       ├── Тест Шапиро-Уилка (нормальность)
+       └── Тесты стационарности (ADF/KPSS)
+```
+
+### Зависимости между функциями:
+
+```
+apply_transformations()
+    ↓
+create_exponential_smoothing_model()
+    ↓
+recursive_forecast() / direct_forecast() / hybrid_forecast()
+    ↓
+inverse_transformations()
+    ↓
+evaluate_forecast()
+    ↓
+diagnose_model_residuals()
+```
+
+---
+
+## 🔄 Как работает программа
+
+### 1. Запуск приложения
+
+```python
+# streamlit_app.py, строка 1648
+if lab_choice == "ЛР №1: ...":
+    render_lab1()
+elif lab_choice == "ЛР №2: ...":
+    render_lab2()
+```
+
+### 2. Выбор лабораторной работы
+
+Пользователь выбирает в sidebar (боковая панель):
+- "ЛР №1: Введение в анализ временных рядов"
+- "ЛР №2: Прогнозирование временных рядов"
+
+### 3. Сохранение состояния
+
+Программа использует `st.session_state` для сохранения:
+- `df_in` - исходные данные
+- `df_clean` - очищенные данные
+- `df_lags` - данные с лагами
+- `decomp` - результат декомпозиции
+- `forecast_results` - результаты прогнозирования
+- `models` - обученные модели
+
+### 4. Обработка данных
+
+Все преобразования применяются последовательно:
+1. Загрузка → `df_in`
+2. Предобработка → `df_clean`
+3. Создание лагов → `df_lags`
+4. Преобразования → `s_train_transformed`
+5. Прогнозирование → `forecast`
+6. Обратное преобразование → `forecast_original`
+
+---
+
+## 📊 Ключевые функции и их назначение
+
+### Предобработка:
+
+| Функция | Что делает |
+|---------|------------|
+| `preprocess_timeseries()` | Основная функция очистки данных |
+| `detect_outliers_iqr()` | Находит выбросы методом IQR |
+| `winsorize_series()` | Обрезает экстремальные значения |
+
+### Анализ:
+
+| Функция | Что делает |
+|---------|------------|
+| `descriptive_statistics()` | Расчёт статистик (mean, std, etc.) |
+| `run_adf()` | Тест стационарности ADF |
+| `run_kpss()` | Тест стационарности KPSS |
+| `get_acf_pacf_with_conf()` | Расчёт ACF/PACF с доверительными интервалами |
+
+### Прогнозирование:
+
+| Функция | Что делает |
+|---------|------------|
+| `apply_transformations()` | Применяет преобразования (log, boxcox, diff) |
+| `create_exponential_smoothing_model()` | Создаёт модель экспоненциального сглаживания |
+| `recursive_forecast()` | Рекурсивная стратегия прогнозирования |
+| `direct_forecast()` | Прямая стратегия прогнозирования |
+| `hybrid_forecast()` | Гибридная стратегия прогнозирования |
+| `inverse_transformations()` | Обратное преобразование прогнозов |
+
+### Оценка:
+
+| Функция | Что делает |
+|---------|------------|
+| `evaluate_forecast()` | Расчёт метрик (MAE, RMSE, MAPE) |
+| `diagnose_model_residuals()` | Диагностика остатков модели |
+
+---
+
+## 🎯 Где что искать
+
+### Если нужно изменить предобработку:
+→ `streamlit_app.py`, функция `preprocess_timeseries()` (строки 97-195)
+
+### Если нужно добавить новую метрику:
+→ `lab2_functions.py`, функция `evaluate_forecast()` (строки 438-451)
+
+### Если нужно изменить визуализацию:
+→ `streamlit_app.py`, функции `render_lab1()` или `render_lab2()`
+
+### Если нужно добавить новую модель:
+→ `lab2_functions.py`, функция `create_exponential_smoothing_model()` (строки 416-435)
+
+### Если нужно изменить стратегию прогнозирования:
+→ `lab2_functions.py`, функции `recursive_forecast()`, `direct_forecast()`, `hybrid_forecast()`
+
+---
+
+## 🔗 Связи между модулями
+
+```
+streamlit_app.py
+    │
+    ├── Импортирует функции из lab2_functions.py
+    │   ├── create_advanced_features()
+    │   ├── apply_transformations()
+    │   ├── recursive_forecast()
+    │   ├── direct_forecast()
+    │   ├── hybrid_forecast()
+    │   ├── create_exponential_smoothing_model()
+    │   ├── evaluate_forecast()
+    │   └── diagnose_model_residuals()
+    │
+    └── Использует библиотеки:
+        ├── pandas - работа с данными
+        ├── numpy - численные вычисления
+        ├── streamlit - веб-интерфейс
+        ├── plotly - интерактивные графики
+        ├── statsmodels - статистические модели
+        └── scipy - научные вычисления
+```
+
+---
+
+## 📝 Примечания
+
+1. **session_state** используется для сохранения состояния между перезагрузками страницы
+2. **Обработка ошибок** - большинство функций имеют try/except блоки
+3. **Визуализация** - используется Plotly для интерактивных графиков
+4. **Модульность** - функции разделены по назначению (предобработка, анализ, прогнозирование)
+
+---
+
+**Для подробного понимания работы программы см. `РУКОВОДСТВО.md`**
+