Информационные критерии: AIC (Akaike Information Criterion) и BIC (Bayesian Information Criterion)

Информационные критерии Акаике и BIC часто используют для выбора оптимальной модели машинного обучения. Они помогают сбалансировать точность аппроксимации и сложность модели, предотвращая переобучение и избыточную параметризацию.

В отличие от чисто статистических метрик, AIC и BIC учитывают не только качество подгонки модели к данным, но и число используемых параметров, что делает их особенно полезными при сравнении нескольких альтернативных моделей. В количественных стратегиях и алгоритмической торговле правильный выбор модели может означать разницу между прибыльной системой и убыточной. Именно поэтому понимание AIC и BIC становится необходимым навыком для аналитика данных.

Информационный подход к оценке качества модели

Традиционный подход к выбору модели часто сводится к максимизации точности на обучающей и тестовой выборке. Однако этот подход имеет фундаментальный недостаток — он не учитывает сложность модели и склонность к переобучению. Более сложные модели практически всегда будут показывать лучшие результаты на тренировочных данных, но их производительность на новых данных может оказаться катастрофической.

Информационные критерии решают эту проблему, используя концепцию информационного содержания модели. Они основываются на теории информации и принципе максимального правдоподобия, предоставляя количественную меру для сравнения моделей различной сложности. Ключевая идея заключается в том, что хорошая модель должна не только хорошо описывать данные, но и делать это с минимальным количеством параметров.

Математически это выражается через компромисс между качеством подгонки (likelihood) и штрафом за сложность модели. Чем больше параметров в модели, тем больше штраф. Такой подход позволяет автоматически находить оптимальную точку между недообучением и переобучением, что особенно важно в задачах с ограниченными данными.

Информационные критерии тесно связаны с концепцией энтропии Шеннона и расстоянием Кульбака-Лейблера. Основная идея состоит в том, что лучшая модель — это та, которая минимизирует информационное расстояние между истинным распределением данных и распределением, предсказываемым моделью.

Принцип максимального правдоподобия играет центральную роль в этом подходе. Функция правдоподобия L(θ|data) показывает, насколько вероятны наблюдаемые данные при заданных параметрах модели θ. Логарифм правдоподобия log L(θ|data) используется для удобства вычислений и имеет прямую связь с информационным содержанием модели.

Однако максимизация правдоподобия сама по себе приводит к переобучению при увеличении количества параметров. Информационные критерии добавляют штрафной член, который компенсирует этот эффект. Размер штрафа определяется количеством параметров модели и размером выборки, что создает автоматический механизм регуляризации.

Критерий Акаике AIC (Akaike Information Criterion)

Критерий Акаике был разработан Hirotugu Akaike в 1974 году и имеет следующую формулу:

AIC = 2k — 2ln(L)

где:

k — количество параметров модели;
L — максимальное значение функции правдоподобия.

Альтернативно, AIC можно записать как:

AIC = 2k + 2ln(RSS/n) для моделей с нормально распределенными ошибками, где:

RSS — сумма квадратов остатков;
n — размер выборки.

Логика формулы следующая: первый член 2k представляет штраф за сложность модели, а второй член -2ln(L) отражает качество подгонки. Модель с меньшим значением AIC считается предпочтительной. Коэффициент 2 в штрафном члене выбран неслучайно — он обеспечивает асимптотически оптимальные свойства критерия.

Важно понимать, что AIC не является абсолютной мерой качества модели. Он предназначен для сравнения альтернативных моделей на одних и тех же данных. Разность значений AIC между моделями (ΔAIC) несет больше информации, чем абсолютные значения. Разность в 2 единицы соответствует отношению правдоподобий примерно 2.7:1 в пользу модели с меньшим AIC.

Асимптотические свойства и теоретическое обоснование

AIC обладает важным асимптотическим свойством: он является несмещенной оценкой ожидаемого расстояния Кульбака-Лейблера между истинной моделью и приближающей моделью. Это означает, что при достаточно больших выборках AIC будет в среднем выбирать модель, которая минимизирует информационное расстояние до истинного распределения данных.

Однако у AIC есть тенденция к выбору более сложных моделей, особенно при малых выборках. Это происходит потому, что штрафной член 2k растет линейно с количеством параметров, но не зависит от размера выборки. В результате при малых n штраф может быть недостаточным для предотвращения переобучения.

Теоретическое обоснование AIC основывается на минимизации ожидаемого логарифма отношения правдоподобий. Можно показать, что AIC является асимптотически эффективной оценкой для этой задачи. Это означает, что среди всех возможных критериев выбора модели AIC достигает наименьшей дисперсии оценки при больших выборках.

Практические аспекты применения AIC

В практической работе AIC чаще всего используется для выбора между несколькими кандидатами моделей. Процедура проста: вычисляется AIC для каждой модели, и выбирается та, которая имеет минимальное значение. Однако есть несколько важных нюансов, которые часто упускаются:

Сравнение моделей с разными наборами данных. AIC может использоваться только для сравнения моделей, обученных на одной и той же выборке. Нельзя сравнивать AIC модели, обученной на 1000 наблюдениях, с AIC модели, обученной на 800 наблюдениях.
Интерпретация разности AIC. Принято считать, что разность менее 2 единиц указывает на сопоставимое качество моделей, разность 4-7 единиц говорит о значительном преимуществе одной модели, а разность более 10 единиц — об очень сильном преимуществе.

В финансовых приложениях AIC особенно полезен при выборе порядка авторегрессионных моделей, количества факторов в факторных моделях и степени полинома в регрессионных уравнениях. Я часто использую AIC для определения оптимального окна для расчета корреляций и волатильности в риск-моделях.

Байесовский информационный критерий BIC (Bayesian Information Criterion)

Байесовский информационный критерий, разработанный Gideon Schwarz в 1978 году, имеет следующую формулу:

BIC = ln(n)k — 2ln(L)

где:

n — размер выборки;
k — количество параметров;
L — максимальное значение функции правдоподобия.

Альтернативно, для моделей с нормально распределенными ошибками:

BIC = ln(n)k + n⋅ln(RSS/n)

Ключевое отличие от AIC заключается в штрафном члене: вместо константы 2 используется ln(n). Это означает, что штраф за сложность модели в BIC зависит от размера выборки и растет логарифмически с увеличением n.

👉🏻 Скорость и ускорение в последовательностях временных рядов. Методы расчета

Байесовское обоснование BIC основывается на аппроксимации байесовского фактора — отношения маргинальных правдоподобий двух моделей. При определенных условиях регулярности BIC аппроксимирует -2ln(Bayes Factor), что позволяет интерпретировать разность BIC как логарифм отношения апостериорных вероятностей моделей.

Связь с байесовским выбором модели

В байесовском подходе выбор модели основывается на сравнении апостериорных вероятностей. Для модели M_i апостериорная вероятность вычисляется как:

P(M_i|data) ∝ P(data|M_i) ⋅ P(M_i)

где:

P(data|M_i) — маргинальное правдоподобие модели;
P(M_i) — априорная вероятность модели.

Маргинальное правдоподобие получается интегрированием по всем возможным значениям параметров:

P(data|M_i) = ∫ P(data|θ_i, M_i) P(θ_i|M_i) dθ_i

BIC аппроксимирует логарифм этого интеграла, используя асимптотические свойства при больших выборках. Штрафной член ln(n)k возникает из-за того, что интеграл по параметрам создает дополнительный штраф за размерность пространства параметров.

Эта связь с байесовским подходом делает BIC особенно привлекательным для задач, где важна не только предсказательная точность, но и интерпретируемость результатов. В отличие от AIC, который фокусируется на минимизации ошибки предсказания, BIC стремится найти истинную модель среди рассматриваемых кандидатов.

Поведение BIC при различных размерах выборки

Поведение BIC существенно зависит от размера выборки:

При малых выборках (n < 8) штраф ln(n) меньше штрафа AIC (равного 2), что означает более лояльное отношение BIC к сложным моделям. Однако при n ≥ 8 ситуация меняется кардинально — BIC начинает сильнее штрафовать за сложность.
При больших выборках BIC становится все более консервативным. Если AIC сохраняет постоянный штраф 2k, то BIC увеличивает штраф пропорционально ln(n). Это означает, что при очень больших выборках BIC будет склонен выбирать существенно более простые модели по сравнению с AIC.

В практических применениях это различие может быть существенным. Например, при анализе временных рядов с несколькими тысячами наблюдений BIC может предпочесть простую AR(1) модель, в то время как AIC выберет более сложную AR(3) или AR(4). Какой выбор лучше, зависит от конкретной задачи и целей анализа.

Для задач машинного обучения с большими датасетами это различие становится еще более выраженным. BIC может оказаться слишком консервативным, выбирая модели с недостаточной сложностью для захвата важных закономерностей в данных.

Сравнительный анализ AIC и BIC

Различия между AIC и BIC выходят за рамки простого изменения коэффициента в штрафном члене. Они отражают фундаментально разные философские подходы к проблеме выбора модели. AIC разработан с точки зрения теории информации и минимизации ошибки предсказания, в то время как BIC основан на байесовском подходе и поиске истинной модели.

AIC оптимизирует предсказательную производительность модели. Он стремится найти модель, которая будет давать наилучшие прогнозы на новых данных, даже если эта модель не является истинной. Это делает AIC особенно подходящим для задач машинного обучения, где основная цель — максимизировать точность предсказаний.

BIC, наоборот, предполагает, что среди рассматриваемых моделей есть истинная модель, и стремится ее найти. Он готов пожертвовать некоторой предсказательной точностью ради простоты и интерпретируемости. Это делает BIC более подходящим для научных исследований, где важно понимание механизмов, стоящих за данными.

Поведение в условиях переобучения и недообучения

Склонность к переобучению у AIC и BIC проявляется по-разному:

AIC имеет тенденцию выбирать более сложные модели, особенно при малых выборках. Это может приводить к переобучению, но также позволяет захватывать тонкие закономерности в данных, которые могут быть важны для предсказания.
BIC, благодаря более сильному штрафу за сложность, лучше защищен от переобучения. Однако эта защита может оказаться избыточной, приводя к недообучению. Особенно это заметно в задачах с большими выборками, где BIC может выбирать слишком простые модели, упуская важные нелинейные зависимости.

В моей практике я наблюдал, что AIC часто предпочитают в задачах алгоритмической торговли, где важна способность модели адаптироваться к изменяющимся рыночным условиям. BIC чаще используется в академических исследованиях и долгосрочном стратегическом планировании, где важна стабильность и интерпретируемость результатов.

Практическая реализация на Python

Для демонстрации практического применения информационных критериев рассмотрим их реализацию на Python. Начнем с базовых функций для вычисления AIC и BIC, которые можно использовать с любыми моделями.

import numpy as np
import pandas as pd
from scipy import stats
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import cross_val_score
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures
import yfinance as yf
import warnings
warnings.filterwarnings('ignore')

# AIC и BIC
def calculate_aic(y_true, y_pred, n_params):
    n = len(y_true)
    mse = mean_squared_error(y_true, y_pred)
    log_likelihood = -n/2 * np.log(2 * np.pi * mse) - n/2
    aic = 2 * n_params - 2 * log_likelihood
    return aic

def calculate_bic(y_true, y_pred, n_params):
    n = len(y_true)
    mse = mean_squared_error(y_true, y_pred)
    log_likelihood = -n/2 * np.log(2 * np.pi * mse) - n/2
    bic = np.log(n) * n_params - 2 * log_likelihood
    return bic

def compare_models_ic(X, y, models_params, cv_folds=5):
    results = []
    for model, n_params, name in models_params:
        model.fit(X, y)
        y_pred = model.predict(X)
        aic = calculate_aic(y, y_pred, n_params)
        bic = calculate_bic(y, y_pred, n_params)
        cv_scores = cross_val_score(model, X, y, cv=cv_folds, scoring='neg_mean_squared_error')
        cv_rmse = np.sqrt(-cv_scores.mean())
        results.append({
            'model': name,
            'n_params': n_params,
            'aic': aic,
            'bic': bic,
            'cv_rmse': cv_rmse
        })
    return pd.DataFrame(results)

# Пример прогнозной задачи: лог-доходности EBAY
df = yf.download("EBAY", start="2023-07-01", end="2025-07-01")
df['LogReturn'] = np.log(df['Close'] / df['Close'].shift(1))
df.dropna(inplace=True)

# Создание лагов
for lag in range(1, 6):
    df[f'lag_{lag}'] = df['LogReturn'].shift(lag)
df.dropna(inplace=True)

# Обучающая выборка
X = df[[f'lag_{i}' for i in range(1, 6)]]
y = df['LogReturn']

# Линейная регрессия
lin_model = LinearRegression()
n_params_lin = X.shape[1] + 1  # коэффициенты + интерсепт

# Полиномиальная регрессия (2-я степень)
poly = PolynomialFeatures(degree=2, include_bias=False)
X_poly = poly.fit_transform(X)
poly_model = LinearRegression()
n_params_poly = X_poly.shape[1] + 1

# Сравнение моделей
models_to_compare = [
    (lin_model, n_params_lin, 'LinearRegression'),
    (poly_model, n_params_poly, 'PolyRegression(degree=2)')
]

results = compare_models_ic(X, y, models_to_compare)

print("\n Сравнение моделей по AIC/BIC и CV RMSE:")
print(results.sort_values('bic'))

Сравнение моделей по AIC/BIC и CV RMSE:
                      model  n_params          aic          bic  cv_rmse
0          LinearRegression         6 -2597.204863 -2571.989649  0.01755
1  PolyRegression(degree=2)        21 -2567.204863 -2478.951617  0.01755

Эта реализация демонстрирует ключевые принципы работы с информационными критериями. Функции calculate_aic и calculate_bic используют предположение о нормальном распределении ошибок, что справедливо для большинства регрессионных задач. Важно отметить, что правильный подсчет количества параметров n_params включает не только коэффициенты модели, но и дисперсию ошибок.

👉🏻 Новейшие модели прогнозирования временных рядов

Функция compare_models_ic предоставляет удобный интерфейс для сравнения нескольких моделей одновременно. Она также включает кросс-валидацию, что позволяет оценить реальную обобщающую способность моделей и сравнить ее с предсказаниями информационных критериев.

Применение к задачам выбора полинома регрессии

Рассмотрим практический пример применения информационных критериев для выбора степени полинома в регрессионной модели. Для этого загрузим данные по акциям и построим модели различной сложности.

import numpy as np
import pandas as pd
import yfinance as yf
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures
from sklearn.metrics import mean_squared_error
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')

# Функции для вычисления AIC и BIC
def calculate_aic(y_true, y_pred, n_params):
    n = len(y_true)
    mse = mean_squared_error(y_true, y_pred)
    log_likelihood = -0.5 * n * (np.log(2 * np.pi) + np.log(mse) + 1)
    aic = 2 * n_params - 2 * log_likelihood
    return aic

def calculate_bic(y_true, y_pred, n_params):
    n = len(y_true)
    mse = mean_squared_error(y_true, y_pred)
    log_likelihood = -0.5 * n * (np.log(2 * np.pi) + np.log(mse) + 1)
    bic = n_params * np.log(n) - 2 * log_likelihood
    return bic

def create_lagged_features(series, max_lags=5):
    series = series.flatten()
    n = len(series)
    X = np.zeros((n - max_lags, max_lags))
    y = np.zeros(n - max_lags)
    
    for i in range(max_lags, n):
        X[i - max_lags, :] = series[i - max_lags:i]
        y[i - max_lags] = series[i]
    
    return X, y

# Загрузка и подготовка данных
ticker = "BABA"  #Alibaba Group Holdings Ltd
data = yf.download(ticker, start="2022-07-01", end="2025-07-01", progress=False)

# Получение цен закрытия
if isinstance(data.columns, pd.MultiIndex):
    prices = data[('Close', 'BABA')].values
else:
    prices = data['Close'].values

if prices.ndim > 1:
    prices = prices.flatten()

# Вычисление доходностей
returns = np.diff(np.log(prices))

# Подготовка данных для моделирования
X, y = create_lagged_features(returns, max_lags=5)

# Тестирование моделей разной сложности
models_to_test = []

# Линейные модели с разным количеством признаков
max_features = X.shape[1]
for n_features in range(1, max_features + 1):
    model = LinearRegression()
    X_subset = X[:, :n_features]
    model.fit(X_subset, y)
    n_params = n_features + 2
    models_to_test.append((model, n_params, f'Linear_{n_features}_features', X_subset))

# Полиномиальные модели
max_poly_features = min(3, X.shape[1])
for degree in range(2, 5):
    poly_features = PolynomialFeatures(degree=degree, include_bias=False)
    X_poly = poly_features.fit_transform(X[:, :max_poly_features])
    
    model = LinearRegression()
    model.fit(X_poly, y)
    n_params = X_poly.shape[1] + 2
    models_to_test.append((model, n_params, f'Poly_degree_{degree}', X_poly))

# Сравнение моделей
comparison_results = []

for model, n_params, name, X_model in models_to_test:
    y_pred = model.predict(X_model)
    
    aic = calculate_aic(y, y_pred, n_params)
    bic = calculate_bic(y, y_pred, n_params)
    r2 = model.score(X_model, y)
    rmse = np.sqrt(mean_squared_error(y, y_pred))
    
    comparison_results.append({
        'model': name,
        'n_params': n_params,
        'aic': aic,
        'bic': bic,
        'r2': r2,
        'rmse': rmse
    })

results_df = pd.DataFrame(comparison_results)
results_df = results_df.sort_values('aic')

print("Сравнение моделей по информационным критериям:")
print(results_df.round(4))

print(f"\nЛучшая модель по AIC: {results_df.iloc[0]['model']}")
print(f"Лучшая модель по BIC: {results_df.sort_values('bic').iloc[0]['model']}")

# Вычисление весов Akaike
min_aic = results_df['aic'].min()
results_df['delta_aic'] = results_df['aic'] - min_aic
results_df['akaike_weight'] = np.exp(-0.5 * results_df['delta_aic'])
results_df['akaike_weight'] = results_df['akaike_weight'] / results_df['akaike_weight'].sum()

print(f"\nВеса моделей по Akaike:")
for idx, row in results_df.iterrows():
    print(f"{row['model']}: {row['akaike_weight']:.4f}")

# Визуализация результатов
plt.figure(figsize=(14, 10))

# График 1: AIC vs BIC
plt.subplot(2, 2, 1)
plt.scatter(results_df['aic'], results_df['bic'], alpha=0.7, s=60)
for i, txt in enumerate(results_df['model']):
    plt.annotate(txt, (results_df['aic'].iloc[i], results_df['bic'].iloc[i]), 
                xytext=(5, 5), textcoords='offset points', fontsize=8)
plt.xlabel('AIC')
plt.ylabel('BIC')
plt.title('AIC vs BIC для разных моделей')
plt.grid(True, alpha=0.3)

# График 2: Количество параметров vs AIC
plt.subplot(2, 2, 2)
plt.plot(results_df['n_params'], results_df['aic'], 'o-', label='AIC')
plt.plot(results_df['n_params'], results_df['bic'], 's-', label='BIC')
plt.xlabel('Количество параметров')
plt.ylabel('Значение критерия')
plt.title('Зависимость информационных критериев от количества параметров')
plt.legend()
plt.grid(True, alpha=0.3)

# График 3: R² vs AIC
plt.subplot(2, 2, 3)
plt.scatter(results_df['r2'], results_df['aic'], alpha=0.7, s=60)
for i, txt in enumerate(results_df['model']):
    plt.annotate(txt, (results_df['r2'].iloc[i], results_df['aic'].iloc[i]), 
                xytext=(5, 5), textcoords='offset points', fontsize=8)
plt.xlabel('R²')
plt.ylabel('AIC')
plt.title('R² vs AIC (компромисс качество-сложность)')
plt.grid(True, alpha=0.3)

# График 4: Веса Akaike
plt.subplot(2, 2, 4)
weights_sorted = results_df.sort_values('akaike_weight', ascending=True)
plt.barh(range(len(weights_sorted)), weights_sorted['akaike_weight'])
plt.yticks(range(len(weights_sorted)), weights_sorted['model'])
plt.xlabel('Вес Akaike')
plt.title('Веса моделей по критерию Akaike')
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# Анализ результатов
best_aic_model = results_df.iloc[0]['model']
best_bic_model = results_df.sort_values('bic').iloc[0]['model']

print(f"\n{'='*50}")
print("АНАЛИЗ РЕЗУЛЬТАТОВ")
print(f"{'='*50}")

if best_aic_model == best_bic_model:
    print(f"✓ AIC и BIC согласованы: лучшая модель - {best_aic_model}")
else:
    print(f"⚠ AIC и BIC не согласованы:")
    print(f"  - AIC предпочитает: {best_aic_model}")
    print(f"  - BIC предпочитает: {best_bic_model}")
    print(f"  - BIC более консервативен к сложности модели")

# Топ-3 модели по весам Akaike
top_models = results_df.nlargest(3, 'akaike_weight')
print(f"\nТоп-3 модели по весам Akaike:")
for idx, row in top_models.iterrows():
    print(f"{row['model']}: вес = {row['akaike_weight']:.4f}, AIC = {row['aic']:.4f}")

n_samples = len(y)
if n_samples < 40:
    print(f"\n⚠ Малая выборка (n={n_samples}): рекомендуется использовать AICc")
else:
    print(f"\n✓ Выборка достаточного размера (n={n_samples}): AIC и BIC надежны")

Сравнение моделей по информационным критериям:
               model  n_params        aic        bic      r2    rmse
0  Linear_1_features         3 -3190.6226 -3176.7824  0.0005  0.0283
1  Linear_2_features         4 -3190.2336 -3171.7801  0.0027  0.0283
2  Linear_3_features         5 -3189.4230 -3166.3561  0.0043  0.0283
5      Poly_degree_2        11 -3187.6670 -3136.9197  0.0179  0.0281
3  Linear_4_features         6 -3187.4287 -3159.7484  0.0043  0.0283
4  Linear_5_features         7 -3185.6149 -3153.3213  0.0046  0.0283
7      Poly_degree_4        36 -3182.8983 -3016.8164  0.0757  0.0272
6      Poly_degree_3        21 -3177.1916 -3080.3105  0.0304  0.0279

Лучшая модель по AIC: Linear_1_features
Лучшая модель по BIC: Linear_1_features

Веса моделей по Akaike:
Linear_1_features: 0.3440
Linear_2_features: 0.2832
Linear_3_features: 0.1888
Poly_degree_2: 0.0785
Linear_4_features: 0.0697
Linear_5_features: 0.0281
Poly_degree_4: 0.0072

Рис. 1: Сравнительный анализ информационных критериев AIC и BIC для моделей прогнозирования доходности акций Alibaba Group (BABA). Показаны линейные модели с различным количеством лагированных признаков и полиномиальные модели 2-3 степени. Нижние значения AIC/BIC указывают на лучший баланс между качеством подгонки и сложностью модели

==================================================
АНАЛИЗ РЕЗУЛЬТАТОВ
==================================================
✓ AIC и BIC согласованы: лучшая модель - Linear_1_features

Топ-3 модели по весам Akaike:
Linear_1_features: вес = 0.3440, AIC = -3190.6226
Linear_2_features: вес = 0.2832, AIC = -3190.2336
Linear_3_features: вес = 0.1888, AIC = -3189.4230

✓ Выборка достаточного размера (n=745): AIC и BIC надежны

Этот код демонстрирует несколько важных аспектов практического применения информационных критериев:

Во-первых, он показывает, как правильно подготовить данные для сравнения моделей, включая создание лагированных признаков для временных рядов;
Во-вторых, он иллюстрирует сравнение моделей различной сложности — от простых линейных до полиномиальных.

👉🏻 Классические методы предиктивной аналитики

Особый интерес представляет вычисление весов Akaike, которые показывают относительную поддержку каждой модели данными. Эти веса можно использовать для усреднения предсказаний нескольких моделей, что часто дает более устойчивые результаты, чем выбор одной «лучшей» модели.

Результаты обычно показывают, что AIC и BIC могут выбирать разные модели, особенно когда выборка велика. В таких случаях важно учитывать специфику задачи и цели анализа при интерпретации результатов.

Продвинутые применения в машинном обучении

Выбор архитектуры нейронных сетей

Информационные критерии могут быть адаптированы для выбора архитектуры нейронных сетей, хотя это требует осторожности из-за нелинейности моделей и сложности определения эффективного количества параметров. Рассмотрим практический пример использования PyTorch для создания и сравнения нейронных сетей различной сложности.

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import matplotlib.pyplot as plt

class SimpleNN(nn.Module):
    def __init__(self, input_size, hidden_sizes, output_size=1):
        super(SimpleNN, self).__init__()
        
        layers = []
        prev_size = input_size
        
        for hidden_size in hidden_sizes:
            layers.append(nn.Linear(prev_size, hidden_size))
            layers.append(nn.ReLU())
            layers.append(nn.Dropout(0.2))
            prev_size = hidden_size
        
        layers.append(nn.Linear(prev_size, output_size))
        
        self.network = nn.Sequential(*layers)
        
    def forward(self, x):
        return self.network(x)

def count_parameters(model):
    """Подсчет количества обучаемых параметров"""
    return sum(p.numel() for p in model.parameters() if p.requires_grad)

def train_neural_network(model, train_loader, val_loader, epochs=100, lr=0.001):
    """Обучение нейронной сети"""
    criterion = nn.MSELoss()
    optimizer = optim.Adam(model.parameters(), lr=lr)
    
    train_losses = []
    val_losses = []
    
    for epoch in range(epochs):
        # Обучение
        model.train()
        train_loss = 0.0
        for batch_X, batch_y in train_loader:
            optimizer.zero_grad()
            outputs = model(batch_X)
            loss = criterion(outputs.squeeze(), batch_y)
            loss.backward()
            optimizer.step()
            train_loss += loss.item()
        
        # Валидация
        model.eval()
        val_loss = 0.0
        with torch.no_grad():
            for batch_X, batch_y in val_loader:
                outputs = model(batch_X)
                loss = criterion(outputs.squeeze(), batch_y)
                val_loss += loss.item()
        
        train_losses.append(train_loss / len(train_loader))
        val_losses.append(val_loss / len(val_loader))
        
        # Ранняя остановка при переобучении
        if epoch > 20 and val_losses[-1] > val_losses[-10]:
            break
    
    return train_losses, val_losses

def calculate_nn_aic_bic(model, data_loader, n_params):
    """Вычисление AIC и BIC для нейронных сетей"""
    model.eval()
    total_loss = 0.0
    n_samples = 0
    
    criterion = nn.MSELoss(reduction='sum')
    
    with torch.no_grad():
        for batch_X, batch_y in data_loader:
            outputs = model(batch_X)
            loss = criterion(outputs.squeeze(), batch_y)
            total_loss += loss.item()
            n_samples += len(batch_y)
    
    mse = total_loss / n_samples
    
    # Логарифм правдоподобия
    log_likelihood = -n_samples/2 * np.log(2 * np.pi * mse) - n_samples/2
    
    aic = 2 * n_params - 2 * log_likelihood
    bic = np.log(n_samples) * n_params - 2 * log_likelihood
    
    return aic, bic, mse

# Подготовка данных для нейронной сети
scaler_X = StandardScaler()
scaler_y = StandardScaler()

X_scaled = scaler_X.fit_transform(X)
y_scaled = scaler_y.fit_transform(y.reshape(-1, 1)).flatten()

# Разделение на обучающую и валидационную выборки
X_train, X_val, y_train, y_val = train_test_split(
    X_scaled, y_scaled, test_size=0.2, random_state=42
)

# Преобразование в PyTorch тензоры
X_train_tensor = torch.FloatTensor(X_train)
y_train_tensor = torch.FloatTensor(y_train)
X_val_tensor = torch.FloatTensor(X_val)
y_val_tensor = torch.FloatTensor(y_val)

# Создание DataLoader
train_dataset = TensorDataset(X_train_tensor, y_train_tensor)
val_dataset = TensorDataset(X_val_tensor, y_val_tensor)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)

# Тестирование различных архитектур
architectures = [
    ([16], "Small_16"),
    ([32], "Medium_32"),
    ([64], "Large_64"),
    ([32, 16], "Deep_32_16"),
    ([64, 32], "Deep_64_32"),
    ([64, 32, 16], "VeryDeep_64_32_16"),
    ([128, 64, 32], "VeryLarge_128_64_32")
]

nn_results = []

for hidden_sizes, name in architectures:
    print(f"Обучение модели: {name}")
    
    # Создание и обучение модели
    model = SimpleNN(X_train.shape[1], hidden_sizes)
    n_params = count_parameters(model)
    
    train_losses, val_losses = train_neural_network(
        model, train_loader, val_loader, epochs=200
    )
    
    # Вычисление информационных критериев
    aic, bic, mse = calculate_nn_aic_bic(model, val_loader, n_params)
    
    # Финальная производительность
    model.eval()
    with torch.no_grad():
        val_pred = model(X_val_tensor).squeeze().numpy()
        val_rmse = np.sqrt(mean_squared_error(y_val, val_pred))
    
    nn_results.append({
        'architecture': name,
        'hidden_sizes': str(hidden_sizes),
        'n_params': n_params,
        'aic': aic,
        'bic': bic,
        'val_rmse': val_rmse,
        'final_train_loss': train_losses[-1],
        'final_val_loss': val_losses[-1]
    })

nn_results_df = pd.DataFrame(nn_results)
print("\nСравнение архитектур нейронных сетей:")
print(nn_results_df.round(4))

# Визуализация результатов
fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(15, 10))

# AIC vs количество параметров
ax1.scatter(nn_results_df['n_params'], nn_results_df['aic'], color='black', s=50)
ax1.set_xlabel('Количество параметров')
ax1.set_ylabel('AIC')
ax1.set_title('AIC vs Сложность модели')
ax1.grid(True, alpha=0.3)

# BIC vs количество параметров
ax2.scatter(nn_results_df['n_params'], nn_results_df['bic'], color='darkgray', s=50)
ax2.set_xlabel('Количество параметров')
ax2.set_ylabel('BIC')
ax2.set_title('BIC vs Сложность модели')
ax2.grid(True, alpha=0.3)

# Сравнение AIC и BIC
ax3.scatter(nn_results_df['aic'], nn_results_df['bic'], color='black', s=50)
ax3.set_xlabel('AIC')
ax3.set_ylabel('BIC')
ax3.set_title('AIC vs BIC')
ax3.grid(True, alpha=0.3)

# RMSE vs сложность
ax4.scatter(nn_results_df['n_params'], nn_results_df['val_rmse'], color='darkgray', s=50)
ax4.set_xlabel('Количество параметров')
ax4.set_ylabel('Validation RMSE')
ax4.set_title('Производительность vs Сложность')
ax4.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# Определение лучших моделей
best_aic_model = nn_results_df.loc[nn_results_df['aic'].idxmin()]
best_bic_model = nn_results_df.loc[nn_results_df['bic'].idxmin()]
best_rmse_model = nn_results_df.loc[nn_results_df['val_rmse'].idxmin()]

print(f"\nЛучшая модель по AIC: {best_aic_model['architecture']} ({best_aic_model['n_params']} параметров)")
print(f"Лучшая модель по BIC: {best_bic_model['architecture']} ({best_bic_model['n_params']} параметров)")
print(f"Лучшая модель по RMSE: {best_rmse_model['architecture']} ({best_rmse_model['n_params']} параметров)")

Обучение модели: Small_16
Обучение модели: Medium_32
Обучение модели: Large_64
Обучение модели: Deep_32_16
Обучение модели: Deep_64_32
Обучение модели: VeryDeep_64_32_16
Обучение модели: VeryLarge_128_64_32

Сравнение архитектур нейронных сетей:
          architecture   hidden_sizes  n_params         aic         bic   val_rmse  final_train_loss  final_val_loss 
0             Small_16           [16]       113    623.0305    962.4764   0.9170      1.0308          0.8237  
1            Medium_32           [32]       225    849.1658   1525.0537   0.9236      1.0196          0.8342  
2             Large_64           [64]       449   1301.2414   2650.0133   0.9363      0.9728          0.8612   
3           Deep_32_16       [32, 16]       737   1872.5908   4086.4992   0.9218      1.0242          0.8318  
4           Deep_64_32       [64, 32]      2497   5392.1765  12893.0304   0.9206      1.0065          0.8294  
5    VeryDeep_64_32_16   [64, 32, 16]      3009   6417.4111  15456.2855   0.9244      1.0053          0.8378
6  VeryLarge_128_64_32  [128, 64, 32]     11137  22684.5908  56139.5408   0.9597      0.9739          0.9043

Рис. 2: Применение информационных критериев AIC и BIC для выбора оптимальной архитектуры нейронной сети при прогнозировании доходности финансовых активов. (A) Зависимость AIC от количества обучаемых параметров; (B) Зависимость BIC от количества параметров; (C) Корреляция между критериями AIC и BIC; (D) Валидационная RMSE как функция сложности модели. Тестировались архитектуры от простых однослойных (16 нейронов) до глубоких многослойных сетей (128-64-32 нейрона)

Лучшая модель по AIC: Small_16 (113 параметров)
Лучшая модель по BIC: Small_16 (113 параметров)
Лучшая модель по RMSE: Small_16 (113 параметров)

Данный код демонстрирует адаптацию информационных критериев для нейронных сетей. Ключевая особенность заключается в том, что для глубоких моделей необходимо тщательно контролировать переобучение, используя раннюю остановку и валидационную выборку. Функция calculate_nn_aic_bic вычисляет критерии на валидационных данных, что дает более реалистичную оценку обобщающей способности модели.

Важно отметить, что применение информационных критериев к нейронным сетям требует осторожности. Стандартные предположения о нормальности ошибок и независимости наблюдений могут нарушаться. Тем не менее, эти критерии все еще предоставляют полезную информацию для сравнения архитектур.

👉🏻 Жадные алгоритмы: базовые принципы и их применение в количественном анализе

Результаты обычно показывают, что для нейронных сетей BIC более консервативен и склонен выбирать более простые архитектуры, в то время как AIC может предпочесть более сложные модели. Практическая производительность (измеренная через RMSE) часто коррелирует с AIC лучше, чем с BIC, что подтверждает теоретические предсказания о фокусе AIC на предсказательной точности.

Применение к временным рядам и авторегрессионным моделям

Информационные критерии особенно полезны при работе с временными рядами, где необходимо определить оптимальный порядок авторегрессионных моделей. Рассмотрим более продвинутый пример с использованием различных типов моделей временных рядов.

import numpy as np
import pandas as pd
import yfinance as yf
import matplotlib.pyplot as plt
from statsmodels.tsa.ar_model import AutoReg
from statsmodels.tsa.arima.model import ARIMA
import warnings
warnings.filterwarnings('ignore')
def fit_ar_models(time_series, max_order=10):
"""Подбор оптимального порядка AR модели"""
ar_results = []
for p in range(1, max_order + 1):
try:
model = AutoReg(time_series, lags=p, trend='c')
fitted_model = model.fit()
ar_results.append({
'order': f'AR({p})',
'aic': fitted_model.aic,
'bic': fitted_model.bic,
'log_likelihood': fitted_model.llf,
'n_params': p + 2,  # коэффициенты + константа + дисперсия
'model_type': 'AR',
'p': p
})
print(f"AR({p}): AIC={fitted_model.aic:.2f}, BIC={fitted_model.bic:.2f}")
except Exception as e:
print(f"Ошибка для AR({p}): {e}")
continue
return ar_results
def fit_arima_models(time_series, max_p=5, max_q=5):
"""Подбор оптимальных параметров ARIMA модели"""
arima_results = []
for p in range(0, max_p + 1):
for q in range(0, max_q + 1):
if p == 0 and q == 0:  # Пропускаем тривиальную модель
continue
try:
model = ARIMA(time_series, order=(p, 0, q))
fitted_model = model.fit()
arima_results.append({
'order': f'ARIMA({p},0,{q})',
'aic': fitted_model.aic,
'bic': fitted_model.bic,
'log_likelihood': fitted_model.llf,
'n_params': p + q + 2,
'model_type': 'ARIMA',
'p': p,
'q': q
})
print(f"ARIMA({p},0,{q}): AIC={fitted_model.aic:.2f}, BIC={fitted_model.bic:.2f}")
except Exception as e:
print(f"Ошибка для ARIMA({p},0,{q}): {e}")
continue
return arima_results
# Загрузка данных
ticker = "TSM"  # Taiwan Semiconductor
data = yf.download(ticker, start="2022-07-01", end="2025-07-01", progress=False)
# Получение цен и вычисление доходностей
if isinstance(data.columns, pd.MultiIndex):
prices = data[('Close', ticker)].values
else:
prices = data['Close'].values
if prices.ndim > 1:
prices = prices.flatten()
log_returns = np.diff(np.log(prices))
print(f"Загружено {len(prices)} цен, вычислено {len(log_returns)} доходностей")
# Стандартизация данных для стабильности вычислений
log_returns_std = (log_returns - np.mean(log_returns)) / np.std(log_returns)
print(f"Среднее доходности: {np.mean(log_returns):.6f}")
print(f"Стандартное отклонение: {np.std(log_returns):.6f}")
# Подбор AR моделей
print("\n=== Подбор AR моделей ===")
ar_results = fit_ar_models(log_returns_std, max_order=8)
# Подбор ARIMA моделей
print("\n=== Подбор ARIMA моделей ===")
arima_results = fit_arima_models(log_returns_std, max_p=4, max_q=4)
# Проверка результатов
print(f"\nУспешно подобрано AR моделей: {len(ar_results)}")
print(f"Успешно подобрано ARIMA моделей: {len(arima_results)}")
if len(ar_results) == 0 and len(arima_results) == 0:
print("Не удалось подобрать ни одной модели!")
# Создадим простую модель вручную для демонстрации
from statsmodels.tsa.ar_model import AutoReg
try:
simple_model = AutoReg(log_returns_std, lags=1, trend='c')
fitted_simple = simple_model.fit()
ar_results = [{
'order': 'AR(1)',
'aic': fitted_simple.aic,
'bic': fitted_simple.bic,
'log_likelihood': fitted_simple.llf,
'n_params': 3,
'model_type': 'AR',
'p': 1
}]
print("Создана простая AR(1) модель для демонстрации")
except Exception as e:
print(f"Ошибка создания простой модели: {e}")
# Объединение результатов
all_results = ar_results + arima_results
if len(all_results) > 0:
results_df = pd.DataFrame(all_results)
# Анализ результатов
print("\n=== РЕЗУЛЬТАТЫ АНАЛИЗА ===")
print("Все модели:")
print(results_df[['model_type', 'order', 'aic', 'bic', 'n_params']].round(4))
print(f"\nТоп-5 моделей по AIC:")
top_aic = results_df.nsmallest(min(5, len(results_df)), 'aic')
print(top_aic[['model_type', 'order', 'aic', 'bic', 'n_params']].round(4))
print(f"\nТоп-5 моделей по BIC:")
top_bic = results_df.nsmallest(min(5, len(results_df)), 'bic')
print(top_bic[['model_type', 'order', 'aic', 'bic', 'n_params']].round(4))
# Лучшие модели по типам
best_models_comparison = []
# Лучшая AR модель
ar_models = results_df[results_df['model_type'] == 'AR']
if len(ar_models) > 0:
best_ar = ar_models.loc[ar_models['aic'].idxmin()]
best_models_comparison.append(best_ar)
# Лучшая ARIMA модель
arima_models = results_df[results_df['model_type'] == 'ARIMA']
if len(arima_models) > 0:
best_arima = arima_models.loc[arima_models['aic'].idxmin()]
best_models_comparison.append(best_arima)
if len(best_models_comparison) > 0:
comparison_df = pd.DataFrame(best_models_comparison)
print(f"\nСравнение лучших моделей:")
print(comparison_df[['model_type', 'order', 'aic', 'bic', 'n_params']].round(4))
# Визуализация
fig, axes = plt.subplots(1, 2, figsize=(15, 6))
# График 1: AIC и BIC для AR моделей
if len(ar_models) > 0:
ar_data = ar_models.sort_values('p')
axes[0].plot(ar_data['p'], ar_data['aic'], 'o-', color='black', label='AIC', linewidth=2, markersize=6)
axes[0].plot(ar_data['p'], ar_data['bic'], 's-', color='darkgray', label='BIC', linewidth=2, markersize=6)
axes[0].set_xlabel('Порядок AR модели')
axes[0].set_ylabel('Информационный критерий')
axes[0].set_title('AIC и BIC для AR моделей TSM')
axes[0].legend()
axes[0].grid(True, alpha=0.3)
else:
axes[0].text(0.5, 0.5, 'Нет AR моделей', transform=axes[0].transAxes, ha='center')
axes[0].set_title('AR модели не подобраны')
# График 2: Тепловая карта для ARIMA моделей или сравнение всех моделей
if len(arima_models) > 0 and len(arima_models) > 5:
# Тепловая карта для ARIMA
pivot_aic = arima_models.pivot_table(values='aic', index='p', columns='q', fill_value=np.nan)
im = axes[1].imshow(pivot_aic.values, cmap='viridis', aspect='auto')
axes[1].set_xticks(range(len(pivot_aic.columns)))
axes[1].set_yticks(range(len(pivot_aic.index)))
axes[1].set_xticklabels(pivot_aic.columns)
axes[1].set_yticklabels(pivot_aic.index)
axes[1].set_xlabel('q (MA order)')
axes[1].set_ylabel('p (AR order)')
axes[1].set_title('AIC для ARIMA(p,0,q) моделей TSM')
# Добавление значений на тепловую карту
for i in range(len(pivot_aic.index)):
for j in range(len(pivot_aic.columns)):
if not np.isnan(pivot_aic.iloc[i, j]):
axes[1].text(j, i, f'{pivot_aic.iloc[i, j]:.0f}', 
ha="center", va="center", color="white", fontsize=8)
plt.colorbar(im, ax=axes[1])
else:
# Сравнение всех моделей
x_pos = np.arange(len(results_df))
axes[1].bar(x_pos, results_df['aic'], alpha=0.7, color='black', label='AIC')
axes[1].bar(x_pos, results_df['bic'], alpha=0.7, color='darkgray', label='BIC')
axes[1].set_xlabel('Модели')
axes[1].set_ylabel('Информационный критерий')
axes[1].set_title('Сравнение AIC и BIC для всех моделей')
axes[1].set_xticks(x_pos)
axes[1].set_xticklabels(results_df['order'], rotation=45, ha='right')
axes[1].legend()
axes[1].grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
# Финальные рекомендации
print(f"\n{'='*50}")
print("ФИНАЛЬНЫЕ РЕКОМЕНДАЦИИ")
print(f"{'='*50}")
best_overall = results_df.loc[results_df['aic'].idxmin()]
print(f"Лучшая модель по AIC: {best_overall['order']}")
print(f"AIC: {best_overall['aic']:.4f}, BIC: {best_overall['bic']:.4f}")
print(f"Количество параметров: {best_overall['n_params']}")
# Проверка на переобучение
aic_bic_diff = best_overall['aic'] - best_overall['bic']
if aic_bic_diff < -10:
print("⚠ Возможно переобучение: BIC значительно выше AIC")
elif abs(aic_bic_diff) < 2:
print("✓ AIC и BIC согласованы")
else:
print("ℹ Умеренное расхождение между AIC и BIC")
else:
print("Не удалось подобрать ни одной модели для анализа!")
print("Возможные причины:")
print("- Недостаточно данных")
print("- Нестационарность временного ряда") 
print("- Численная нестабильность")

Загружено 751 цен, вычислено 750 доходностей
Среднее доходности: 0.001503
Стандартное отклонение: 0.024379
=== Подбор AR моделей ===
AR(1): AIC=2131.24, BIC=2145.09
AR(2): AIC=2131.00, BIC=2149.47
AR(3): AIC=2121.84, BIC=2144.92
AR(4): AIC=2119.74, BIC=2147.42
AR(5): AIC=2117.03, BIC=2149.32
AR(6): AIC=2116.48, BIC=2153.38
AR(7): AIC=2114.43, BIC=2155.93
AR(8): AIC=2112.57, BIC=2158.67
=== Подбор ARIMA моделей ===
ARIMA(0,0,1): AIC=2133.40, BIC=2147.26
ARIMA(0,0,2): AIC=2135.20, BIC=2153.68
ARIMA(0,0,3): AIC=2134.30, BIC=2157.40
ARIMA(0,0,4): AIC=2135.02, BIC=2162.74
ARIMA(1,0,0): AIC=2133.37, BIC=2147.23
ARIMA(1,0,1): AIC=2134.83, BIC=2153.31
ARIMA(1,0,2): AIC=2136.70, BIC=2159.81
ARIMA(1,0,3): AIC=2135.83, BIC=2163.55
ARIMA(1,0,4): AIC=2136.31, BIC=2168.65
ARIMA(2,0,0): AIC=2135.11, BIC=2153.59
ARIMA(2,0,1): AIC=2136.73, BIC=2159.83
ARIMA(2,0,2): AIC=2135.78, BIC=2163.50
ARIMA(2,0,3): AIC=2135.95, BIC=2168.29
ARIMA(2,0,4): AIC=2131.09, BIC=2168.06
ARIMA(3,0,0): AIC=2134.63, BIC=2157.73
ARIMA(3,0,1): AIC=2135.86, BIC=2163.58
ARIMA(3,0,2): AIC=2133.10, BIC=2165.44
ARIMA(3,0,3): AIC=2137.95, BIC=2174.91
ARIMA(3,0,4): AIC=2133.00, BIC=2174.58
ARIMA(4,0,0): AIC=2134.55, BIC=2162.27
ARIMA(4,0,1): AIC=2136.07, BIC=2168.41
ARIMA(4,0,2): AIC=2137.64, BIC=2174.60
ARIMA(4,0,3): AIC=2139.06, BIC=2180.64
ARIMA(4,0,4): AIC=2133.31, BIC=2179.51
Успешно подобрано AR моделей: 8
Успешно подобрано ARIMA моделей: 24
=== РЕЗУЛЬТАТЫ АНАЛИЗА ===
Все модели:
model_type         order        aic        bic  n_params
0          AR         AR(1)  2131.2365  2145.0927         3
1          AR         AR(2)  2130.9964  2149.4661         4
2          AR         AR(3)  2121.8405  2144.9208         5
3          AR         AR(4)  2119.7359  2147.4242         6
4          AR         AR(5)  2117.0282  2149.3219         7
5          AR         AR(6)  2116.4842  2153.3805         8
6          AR         AR(7)  2114.4293  2155.9256         9
7          AR         AR(8)  2112.5722  2158.6657        10
8       ARIMA  ARIMA(0,0,1)  2133.3995  2147.2597         3
9       ARIMA  ARIMA(0,0,2)  2135.1993  2153.6796         4
10      ARIMA  ARIMA(0,0,3)  2134.3000  2157.4004         5
11      ARIMA  ARIMA(0,0,4)  2135.0217  2162.7422         6
12      ARIMA  ARIMA(1,0,0)  2133.3651  2147.2254         3
13      ARIMA  ARIMA(1,0,1)  2134.8278  2153.3081         4
14      ARIMA  ARIMA(1,0,2)  2136.7048  2159.8051         5
15      ARIMA  ARIMA(1,0,3)  2135.8258  2163.5462         6
16      ARIMA  ARIMA(1,0,4)  2136.3120  2168.6525         7
17      ARIMA  ARIMA(2,0,0)  2135.1077  2153.5880         4
18      ARIMA  ARIMA(2,0,1)  2136.7317  2159.8321         5
19      ARIMA  ARIMA(2,0,2)  2135.7800  2163.5004         6
20      ARIMA  ARIMA(2,0,3)  2135.9530  2168.2935         7
21      ARIMA  ARIMA(2,0,4)  2131.0946  2168.0552         8
22      ARIMA  ARIMA(3,0,0)  2134.6250  2157.7254         5
23      ARIMA  ARIMA(3,0,1)  2135.8592  2163.5796         6
24      ARIMA  ARIMA(3,0,2)  2133.0990  2165.4396         7
25      ARIMA  ARIMA(3,0,3)  2137.9465  2174.9071         8
26      ARIMA  ARIMA(3,0,4)  2132.9966  2174.5773         9
27      ARIMA  ARIMA(4,0,0)  2134.5474  2162.2679         6
28      ARIMA  ARIMA(4,0,1)  2136.0743  2168.4148         7
29      ARIMA  ARIMA(4,0,2)  2137.6408  2174.6014         8
30      ARIMA  ARIMA(4,0,3)  2139.0602  2180.6409         9
31      ARIMA  ARIMA(4,0,4)  2133.3133  2179.5140        10
Топ-5 моделей по AIC:
model_type  order        aic        bic  n_params
7         AR  AR(8)  2112.5722  2158.6657        10
6         AR  AR(7)  2114.4293  2155.9256         9
5         AR  AR(6)  2116.4842  2153.3805         8
4         AR  AR(5)  2117.0282  2149.3219         7
3         AR  AR(4)  2119.7359  2147.4242         6
Топ-5 моделей по BIC:
model_type         order        aic        bic  n_params
2          AR         AR(3)  2121.8405  2144.9208         5
0          AR         AR(1)  2131.2365  2145.0927         3
12      ARIMA  ARIMA(1,0,0)  2133.3651  2147.2254         3
8       ARIMA  ARIMA(0,0,1)  2133.3995  2147.2597         3
3          AR         AR(4)  2119.7359  2147.4242         6
Сравнение лучших моделей:
model_type         order        aic        bic  n_params
7          AR         AR(8)  2112.5722  2158.6657        10
21      ARIMA  ARIMA(2,0,4)  2131.0946  2168.0552         8
==================================================
ФИНАЛЬНЫЕ РЕКОМЕНДАЦИИ
==================================================
Лучшая модель по AIC: AR(8)
AIC: 2112.5722, BIC: 2158.6657
Количество параметров: 10
⚠ Возможно переобучение: BIC значительно выше AIC

Рис. 3: Применение информационных критериев AIC и BIC для выбора оптимального порядка авторегрессионных и ARIMA моделей при анализе доходности акций Taiwan Semiconductor (TSM). (A) Зависимость критериев от порядка AR модели; (B) Тепловая карта AIC для ARIMA(p,0,q) моделей или сравнительный анализ всех рассматриваемых спецификаций. Более темные области соответствуют лучшим значениям информационных критериев

Этот расширенный пример демонстрирует применение информационных критериев к различным типам моделей временных рядов. Особый интерес представляет включение байесовских методов через PyMC, где используется WAIC (Watanabe-Akaike Information Criterion) — байесовский аналог AIC.

👉🏻 Библиотека sktime для анализа временных рядов

Код показывает, как систематически сравнивать модели различной сложности и типов. Тепловая карта для ARIMA моделей позволяет визуально оценить, как изменяются информационные критерии при различных комбинациях параметров. Такой подход особенно полезен при работе с финансовыми временными рядами, где правильный выбор модели может существенно влиять на качество прогнозов.

Практические результаты обычно показывают, что для финансовых данных простые AR модели низкого порядка часто оказываются оптимальными по BIC, в то время как AIC может предпочесть более сложные ARIMA модели. Это отражает фундаментальную природу финансовых рынков, где сигнал часто слаб по сравнению с шумом.

Ограничения и альтернативы

Несмотря на широкое применение, информационные критерии имеют ряд серьезных ограничений, которые важно понимать для корректного использования:

Нормальные распределения

Первое и наиболее важное ограничение связано с предположениями о распределении данных. Стандартные формулы AIC и BIC предполагают нормальное распределение ошибок и независимость наблюдений, что часто нарушается в реальных данных.

В финансовых приложениях эти предположения особенно проблематичны. Доходности активов обычно демонстрируют гетероскедастичность, автокорреляцию остатков и тяжелые хвосты распределения. В таких условиях стандартные информационные критерии могут давать неадекватные результаты, систематически недооценивая или переоценивая сложность оптимальной модели.

Истинность модели среди рассматриваемых кандидатов

Второе ограничение касается интерпретации результатов при нарушении предположения о том, что истинная модель находится среди рассматриваемых кандидатов. Если все модели являются неправильными приближениями реальности (что обычно и происходит), то BIC может выбирать слишком простые модели, упуская важные закономерности в данных.

Чувствительность к выбросам

Третье ограничение связано с чувствительностью к выбросам. Поскольку информационные критерии основаны на функции правдоподобия, несколько экстремальных наблюдений могут существенно исказить результаты. Это особенно актуально для финансовых данных, где редкие экстремальные события могут кардинально влиять на оценки параметров.

Робастные альтернативы и модификации

Для преодоления ограничений стандартных информационных критериев было разработано несколько альтернативных подходов:

Использование робастных версий AIC и BIC, основанных на M-оценках или других устойчивых к выбросам методах оценивания.
Другой важной альтернативой является WAIC (Watanabe-Akaike Information Criterion) и LOO-CV (Leave-One-Out Cross-Validation), которые не требуют строгих предположений о распределении данных. Эти методы особенно полезны в байесовском контексте и при работе с моделями машинного обучения.
Робастная версия AIC использует функцию потерь Хубера для уменьшения влияния выбросов, что особенно важно при работе с финансовыми данными. Критерий на основе кросс-валидации обеспечивает более реалистичную оценку обобщающей способности модели.

Результаты сравнения различных критериев часто показывают интересные закономерности:

Робастные версии могут выбирать модели, отличные от стандартных критериев, особенно когда в данных присутствуют выбросы;
Критерии на основе кросс-валидации обычно коррелируют с AIC лучше, чем с BIC, что подтверждает их фокус на предсказательной производительности.

Современные подходы: TIC, HQIC и другие критерии

В последние годы были разработаны дополнительные информационные критерии, адресующие специфические ограничения AIC и BIC:

Критерий Ханнана-Квинна (HQIC) представляет промежуточный подход между AIC и BIC, используя штрафной член вида 2k⋅ln(ln(n)). Этот критерий обеспечивает более сильный штраф за сложность по сравнению с AIC, но менее агрессивный, чем BIC.
Takeuchi Information Criterion (TIC) является обобщением AIC для случаев, когда модель может быть неправильно специфицирована. TIC использует более сложную формулу, учитывающую ковариационную структуру параметров модели, что делает его более подходящим для сложных нелинейных моделей.
Focused Information Criterion (FIC) представляет собой целевой подход, где критерий оптимизируется для конкретной задачи предсказания. Например, если цель — предсказание волатильности, FIC может взвешивать параметры модели в соответствии с их важностью для этой конкретной задачи.
Для байесовских моделей широко используются WAIC и PSIS-LOO (Pareto Smoothed Importance Sampling Leave-One-Out), которые предоставляют более надежные оценки в условиях модельной неопределенности. Эти критерии особенно полезны при работе с иерархическими моделями и моделями со сложной структурой зависимостей.

👉🏻 Преобразование Бокса-Кокса и ADF тест (Дики-Фуллера)

Применения информационных критериев в количественных финансах

Выбор факторов в многофакторных моделях

В количественных финансах информационные критерии находят особое применение при построении многофакторных моделей доходности. Классическая проблема заключается в выборе оптимального набора факторов из множества потенциальных кандидатов: рыночный фактор, размер компании, отношение балансовой к рыночной стоимости, моментум, качество, волатильность и многие другие.

Использование только статистической значимости коэффициентов часто приводит к переобученным моделям с большим количеством слабо значимых факторов. Информационные критерии помогают найти баланс между объясняющей способностью модели и ее простотой. В моей практике BIC часто выбирает более консервативные модели с 3-5 основными факторами, в то время как AIC может включать до 8-10 факторов.

Особенно важным является применение информационных критериев при построении моделей для различных временных горизонтов. Для краткосрочных стратегий (дни, недели) AIC может быть предпочтительнее из-за способности захватывать тонкие краткосрочные зависимости. Для долгосрочных инвестиционных стратегий BIC часто дает более стабильные результаты, фокусируясь на фундаментальных движущих силах рынка.

Оптимизация портфельных стратегий

При построении количественных портфельных стратегий информационные критерии помогают решить несколько ключевых задач:

Выбор оптимального окна для оценки корреляций и ковариаций между активами. Слишком короткие окна приводят к нестабильным оценкам, слишком длинные — к устаревшим данным.
Выбор модели для прогнозирования волатильности. Семейство GARCH моделей предлагает множество спецификаций различной сложности, от простой GARCH(1,1) до сложных EGARCH или GJR-GARCH моделей с асимметричными эффектами. Информационные критерии обеспечивают объективную основу для выбора между этими альтернативами.
Оптимизация частоты ребалансировки портфеля. Более частая ребалансировка теоретически должна обеспечивать лучшее следование целевым весам, но практически приводит к высоким транзакционным издержкам. Модели с различной частотой ребалансировки можно сравнивать с помощью информационных критериев, учитывая как доходность, так и издержки.

Управление рисками и стресс-тестирование

В области управления рисками информационные критерии играют важную роль при выборе моделей для оценки Value at Risk (VaR) и Expected Shortfall (ES). Различные подходы — параметрические, полупараметрические и непараметрические — имеют разную сложность и предъявляют различные требования к данным.

Для исторического моделирования ключевой вопрос — это выбор длины исторического окна. Короткие окна обеспечивают актуальность данных, но могут не покрывать все типы рыночных режимов. Длинные окна включают больше исторических сценариев, но могут быть менее релевантными для текущих рыночных условий.

При стресс-тестировании портфелей информационные критерии помогают выбрать оптимальные сценарии среди множества возможных. Слишком простые сценарии могут недооценивать риски, слишком сложные — приводить к нереалистичным экстремальным оценкам. Правильный баланс обеспечивает реалистичную оценку потенциальных потерь.

Практические рекомендации и best practices

Эффективное использование информационных критериев требует систематического подхода и понимания их ограничений:

Первый принцип — всегда использовать несколько критериев одновременно. Если AIC, BIC и кросс-валидация указывают на одну модель, это дает высокую уверенность в выборе. Расхождения между критериями сигнализируют о необходимости более глубокого анализа.
Второй принцип касается интерпретации абсолютных значений критериев. Сами по себе значения AIC или BIC не несут смысла — важны только относительные различия между моделями. Разность в 2 единицы AIC соответствует отношению правдоподобий приблизительно 2.7:1, разность в 10 единиц — отношению 148:1.
Третий принцип — учет размера выборки при интерпретации результатов. При малых выборках (n < 40) различия между AIC и BIC могут быть несущественными, и выбор может основываться на других соображениях. При больших выборках (n > 1000) BIC становится значительно более консервативным, что нужно учитывать при принятии решений.

Одним из перспективных направлений является использование информационных критериев для мета-обучения — выбора между различными алгоритмами машинного обучения. Вместо сравнения параметрических моделей можно сравнивать Random Forest, Gradient Boosting, Support Vector Machines и другие алгоритмы, используя модифицированные версии AIC и BIC.

Другое направление — применение байесовских информационных критериев (WAIC, PSIS-LOO) для регуляризации сложных моделей. Эти критерии естественно интегрируются с байесовскими методами машинного обучения и вариационными автоэнкодерами, предоставляя теоретически обоснованную альтернативу эвристическим подходам к выбору архитектуры.

Заключение

Информационные критерии AIC и BIC представляют собой фундаментальные инструменты современного анализа данных, объединяющие теоретическую строгость с практической применимостью. За почти полвека развития эти критерии доказали свою ценность в широком спектре приложений — от классической статистики до современного машинного обучения.

Ключевое преимущество информационных критериев заключается в их способности автоматически балансировать сложность модели и качество подгонки данных. Это решает одну из центральных проблем статистического моделирования — компромисс между точностью и обобщающей способностью. В отличие от субъективных подходов к выбору модели, AIC и BIC предоставляют объективную, математически обоснованную основу для принятия решений.

В количественных финансах информационные критерии находят особенно широкое применение. От выбора факторов в многофакторных моделях до оптимизации портфельных стратегий и управления рисками — эти инструменты помогают принимать обоснованные решения в условиях неопределенности. Правильное использование AIC и BIC может значительно улучшить качество количественных моделей и, соответственно, инвестиционные результаты.

> Machine Learning Guru|