Основы Бэггинга (Bootstrap Aggregating) в машинном обучении

Введение в ансамблевые методы и математические основы бутстрэпа

Добро пожаловать в курс «Основы Бэггинга в машинном обучении». Это первая статья, в которой мы заложим фундамент для понимания одного из самых мощных и популярных подходов в Data Science — бэггинга. Прежде чем мы перейдем к алгоритмам вроде Random Forest, нам необходимо разобраться, что такое ансамбли, зачем они нужны и какая математическая магия стоит за странным словом «бутстрэп».

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

Представьте, что вы участвуете в викторине «Кто хочет стать миллионером?». Вы дошли до сложного вопроса и не знаете ответа. У вас есть две подсказки: «Звонок другу» (пусть это будет очень умный профессор) или «Помощь зала».

Интуитивно кажется, что профессор знает больше, чем случайный зритель в студии. Однако статистика утверждает обратное: усредненное мнение большой группы людей (зала) часто оказывается точнее, чем мнение одного, даже очень квалифицированного эксперта. Этот феномен известен как «Мудрость толпы».

В машинном обучении этот принцип реализуется через ансамблевые методы (Ensemble Methods).

> Ансамбль — это метод машинного обучения, который объединяет прогнозы нескольких базовых моделей (алгоритмов) для получения одного итогового прогноза, обладающего лучшим качеством, чем каждая из моделей по отдельности.

!Сравнение работы одиночной модели и ансамбля моделей

Основные семейства ансамблей

В мире машинного обучения существует три главных подхода к созданию ансамблей:

Бэггинг (Bagging) — параллельное обучение независимых моделей и усреднение их ответов. Именно этому методу посвящен наш курс.

Бустинг (Boosting) — последовательное обучение моделей, где каждая следующая исправляет ошибки предыдущей.

Стекинг (Stacking) — обучение нескольких разных моделей и использование еще одной «финальной» модели для объединения их предсказаний.

Чтобы понять, почему бэггинг работает, нам нужно погрузиться в одну из фундаментальных проблем машинного обучения — дилемму смещения и разброса.

Дилемма смещения и разброса (Bias-Variance Tradeoff)

Любая ошибка модели машинного обучения складывается из трех компонентов. Математически это можно записать следующим образом:

Где: * — полная ошибка модели на тестовом примере . * (Смещение) — ошибка, возникающая из-за ошибочных предположений в алгоритме обучения. Высокое смещение приводит к недообучению (модель слишком простая и упускает важные закономерности). * (Разброс) — ошибка, возникающая из-за чрезмерной чувствительности к малым колебаниям в обучающем наборе. Высокий разброс приводит к переобучению (модель запоминает шум вместо сигнала). * (Неустранимая ошибка) — шум в самих данных, который невозможно убрать никаким алгоритмом.

!Графическая иллюстрация компромисса между смещением и разбросом

Главная цель бэггинга — снижение разброса (Variance) без существенного увеличения смещения.

Если у нас есть множество моделей, которые переобучаются (имеют высокий разброс), но ошибаются по-разному, то их усреднение позволит сгладить эти ошибки. Именно для создания таких «разных» моделей на одних и тех же данных используется метод бутстрэпа.

Бутстрэп (Bootstrap): математическое сердце метода

Слово «Bootstrap» происходит от выражения "to pull oneself up by one's bootstraps" (вытянуть себя за шнурки ботинок), что означает сделать что-то невозможное собственными силами. В статистике это метод генерации выборок.

Представьте, что у нас есть исходный набор данных размером . Чтобы обучить много разных моделей, нам нужно много разных наборов данных. Но где их взять, если у нас есть только один ?

Мы создаем новые выборки того же размера , выбирая объекты из исходного набора случайным образом с возвращением.

Как работает выборка с возвращением?

У нас есть мешок с пронумерованными шарами.

Мы достаем один шар, записываем его номер.

Возвращаем шар обратно в мешок и перемешиваем.

Повторяем процедуру раз.

В результате в новой выборке (бутстрэп-выборке) некоторые объекты могут встретиться два, три и более раз, а некоторые — не встретиться вовсе.

Вероятность попадания объекта в выборку

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

Пусть размер выборки равен . Вероятность вытащить конкретный объект в одной попытке равна:

Где: * — вероятность выбрать конкретный объект. * — общее количество объектов.

Соответственно, вероятность не вытащить этот объект в одной попытке:

Где: * — вероятность того, что конкретный объект не будет выбран.

Поскольку мы делаем независимых попыток, чтобы сформировать новую выборку, вероятность того, что объект ни разу не попадет в бутстрэп-выборку, равна произведению вероятностей для каждой попытки:

Где: * — вероятность того, что объект вообще не попадет в новую выборку после попыток.

Предел при больших данных

Что происходит, когда данных много (то есть стремится к бесконечности)? Мы можем использовать второй замечательный предел:

Где: * — число Эйлера, математическая константа, приблизительно равная .

Давайте вычислим значение:

Вывод: Вероятность того, что конкретный объект не попадет в бутстрэп-выборку, составляет примерно 36.8%.

Следовательно, вероятность того, что объект попадет в выборку хотя бы один раз:

Где: * — доля уникальных объектов из исходного датасета, которые попадают в бутстрэп-выборку.

Это знаменитое правило 63.2%. В среднем каждая бутстрэп-выборка содержит лишь около 63% уникальных примеров из исходного набора данных. Остальные 37% примеров называются Out-of-Bag (OOB) выборкой.

> Важно: OOB-примеры играют огромную роль. Поскольку модель не видела эти данные при обучении, их можно использовать для валидации (проверки качества) модели без необходимости выделять отдельную отложенную выборку.

!Визуализация создания бутстрэп-выборок с повторениями

От Бутстрэпа к Бэггингу

Теперь, когда мы понимаем математику бутстрэпа, концепция Бэггинга становится простой. Само название Bagging — это сокращение от Bootstrap Aggregating.

Алгоритм выглядит так:

Bootstrap: Создаем случайных выборок из исходных данных методом бутстрэпа.

Train: Обучаем независимых базовых моделей (например, решающих деревьев) — по одной на каждую выборку.

Aggregating: Объединяем предсказания всех моделей.

Методы агрегации

Как именно объединить ответы моделей? Это зависит от типа задачи.

#### 1. Для задач регрессии (предсказание числа) Используется простое усреднение:

Где: * — итоговое предсказание ансамбля. * — количество моделей. * — предсказание -й модели для объекта .

#### 2. Для задач классификации (предсказание класса) Используется голосование (Voting).

* Жесткое голосование (Hard Voting): Каждая модель голосует за класс. Побеждает класс, набравший большинство голосов (мода). * Мягкое голосование (Soft Voting): Модели выдают вероятности принадлежности к классам. Эти вероятности усредняются, и выбирается класс с наибольшей средней вероятностью. Мягкое голосование часто дает более точные результаты, так как учитывает «уверенность» моделей.

Почему это работает?

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

Именно поэтому для бэггинга идеально подходят нестабильные алгоритмы, такие как глубокие решающие деревья. Если чуть-чуть изменить данные, дерево построится совершенно иначе. Бутстрэп обеспечивает это «чуть-чуть изменение» данных, а агрегация сглаживает нестабильность.

Заключение

Мы разобрали фундамент ансамблевых методов. Вы узнали, что: * Ансамбли используют «мудрость толпы» для улучшения прогнозов. * Бэггинг борется с высоким разбросом (Variance) моделей. * Бутстрэп — это метод генерации выборок с возвращением, где каждая выборка содержит около 63.2% уникальных данных. * Оставшиеся 36.8% данных (OOB) можно использовать для бесплатной валидации.

В следующей статье мы перейдем от теории к практике и разберем самый известный алгоритм, основанный на бэггинге — Случайный лес (Random Forest).

Алгоритм бэггинга: параллельное обучение моделей и методы агрегации предсказаний

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

Сегодня мы детально разберем алгоритм Бэггинга (Bagging). Мы узнаем, почему его можно распараллелить на сотни процессоров, как именно демократия работает внутри алгоритмов и почему усреднение ответов глупых моделей делает их умными.

Общая схема алгоритма

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

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

Генерация выборок (Bootstrap): Из исходного датасета создается случайных подвыборок с возвращением.

Параллельное обучение (Parallel Training): На каждой из выборок обучается своя базовая модель (Base Learner). Эти модели обучаются совершенно независимо друг от друга.

Агрегация (Aggregation): Предсказания всех моделей объединяются для получения финального ответа.

!Блок-схема процесса бэггинга: от данных до финального решения

Ключевая особенность: Параллелизм

Одной из важнейших характеристик бэггинга является независимость базовых моделей. Модель №5 ничего не знает о существовании Модели №1 или Модели №10. Она видит только свою бутстрэп-выборку и пытается минимизировать ошибку на ней.

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

Методы агрегации: как договориться моделям?

Представьте, что мы обучили 100 моделей. Приходит новый объект (например, клиент банка), и мы хотим предсказать, вернет ли он кредит. 30 моделей говорят «Не вернет», 70 говорят «Вернет». Как принять решение?

Метод агрегации зависит от типа решаемой задачи: регрессии или классификации.

1. Агрегация в задачах регрессии

В задаче регрессии модель предсказывает непрерывное число (например, цену квартиры). Самый простой и популярный способ объединения — простое усреднение.

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

Где: * — итоговое предсказание ансамбля (бэггинга). * — общее количество базовых моделей. * — предсказание -й модели для входного объекта . * — знак суммирования (мы складываем все предсказания).

Пример: Три модели предсказали цену дома: 5 млн, 6 млн и 13 млн. Среднее арифметическое: млн.

Однако, среднее арифметическое чувствительно к выбросам. Если одна модель сошла с ума и предсказала 100 млн, среднее сильно сместится. В таких случаях используют медиану — число, которое находится ровно посередине отсортированного ряда ответов.

2. Агрегация в задачах классификации

Здесь у нас есть два основных подхода: жесткое и мягкое голосование.

#### Жесткое голосование (Hard Voting)

Это классическая демократия. Каждая модель отдает свой голос за определенный класс. Побеждает класс, набравший большинство голосов (мода).

Где: * — операция поиска наиболее часто встречающегося значения.

Если у нас бинарная классификация (0 или 1) и нечетное число моделей, проблем не возникает. Если число моделей четное и голоса разделились 50/50, решение может выбираться случайно или в пользу класса с большим приоритетом.

#### Мягкое голосование (Soft Voting)

Этот метод часто работает лучше, так как учитывает уверенность моделей. Вместо того чтобы просто сказать «Класс А», модель выдает вероятность принадлежности к этому классу (например, «Я на 80% уверена, что это Класс А»).

Алгоритм:

Суммируем вероятности для каждого класса по всем моделям.

Делим на количество моделей (усредняем вероятности).

Выбираем класс с наибольшей средней вероятностью.

Пример: У нас есть 3 модели, классифицирующие изображение (Кот или Пес).

| Модель | Голос (Hard) | Вероятность "Кот" | Вероятность "Пес" | | :--- | :--- | :--- | :--- | | Модель 1 | Кот | 0.90 | 0.10 | | Модель 2 | Кот | 0.51 | 0.49 | | Модель 3 | Пес | 0.30 | 0.70 |

* Жесткое голосование: 2 голоса за Кота, 1 за Пса. Побеждает Кот. * Мягкое голосование: * Среднее за Кота: * Среднее за Пса: * Побеждает Кот (с уверенностью 57%).

Заметьте, что Модель 2 была очень неуверенна (51%), но в жестком голосовании её голос весил столько же, сколько голос уверенной Модели 1. Мягкое голосование сглаживает этот недостаток.

Математика снижения разброса (Variance)

Почему усреднение вообще работает? Интуитивно понятно, что «одна голова хорошо, а две лучше». Но давайте посмотрим на это с точки зрения статистики.

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

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

Где: * — дисперсия ансамбля (усредненного ответа). * — дисперсия одной отдельной модели. * — количество моделей.

Это идеальный сценарий! Если мы возьмем 100 независимых моделей, мы уменьшим ошибку разброса в 100 раз. Но в реальности модели не являются независимыми, потому что они обучаются на пересекающихся данных (из-за бутстрэпа).

Для коррелированных величин формула сложнее:

Где: * (ро) — коэффициент корреляции между предсказаниями моделей (число от 0 до 1, показывающее, насколько похоже ошибаются модели).

Давайте проанализируем эту формулу, она критически важна для понимания сути бэггинга:

Если (количество моделей) очень большое, то второе слагаемое стремится к нулю.

Остается первое слагаемое: .

Вывод: Предел качества бэггинга ограничен корреляцией между моделями.

* Если модели идентичны (корреляция ), то бэггинг бесполезен. Усреднение 100 одинаковых мнений не даст прироста истины. * Чем разнообразнее модели (чем меньше ), тем сильнее падает общая ошибка.

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

Какие модели выбирать для Бэггинга?

Исходя из формулы выше, нам нужны модели, которые:

Имеют низкое смещение (Bias) — то есть они достаточно сложные и умные, чтобы выучить закономерности.

Имеют высокий разброс (Variance) — то есть они нестабильны и сильно меняются при малейшем изменении обучающих данных (это обеспечивает низкую корреляцию).

Идеальный кандидат — глубокие решающие деревья.

* Если дерево не ограничивать по глубине, оно идеально подстроится под обучающую выборку (низкое смещение). * Но если изменить пару объектов в данных, структура дерева может кардинально поменяться (высокий разброс).

Бэггинг берет эти «нервные», переобученные деревья и усредняет их, получая стабильный и точный результат. А вот линейные модели (например, логистическая регрессия) для бэггинга подходят плохо — они слишком стабильны. Изменение данных мало влияет на их коэффициенты, корреляция между ними будет высокой, и выигрыша от ансамбля почти не будет.

Преимущества и недостатки Бэггинга

Подводя итог, соберем плюсы и минусы этого подхода.

Преимущества

* Снижение переобучения: Превращает нестабильные модели в надежный ансамбль. * Параллелизм: Легко масштабируется на кластерах серверов. * OOB-валидация: Позволяет оценивать качество модели «на лету» без выделения отдельной тестовой выборки (как мы обсуждали в прошлой статье). * Устойчивость к шуму: В задачах регрессии усреднение сглаживает влияние случайных выбросов.

Недостатки

* Потеря интерпретируемости: Одно дерево решений легко понять (если , то ). Ансамбль из 500 деревьев — это «черный ящик». Мы знаем ответ, но сложно понять логику его получения. * Вычислительная сложность: Обучение и хранение 500 моделей требует в 500 раз больше памяти и времени (хотя время можно сократить параллелизмом). * Не исправляет смещение (Bias): Если базовая модель слишком простая (недообученная), бэггинг не сделает её умнее, он только усреднит её глупость. Поэтому важно использовать глубокие деревья.

Заключение

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

Однако, даже с бутстрэпом, обычные решающие деревья могут быть слишком похожими друг на друга (коррелированными), если в данных есть один очень сильный признак. Чтобы решить эту проблему и снизить корреляцию еще сильнее, был придуман алгоритм Random Forest (Случайный лес). О нем мы поговорим в следующей статье.

Случайный лес (Random Forest): эволюция бэггинга и декорреляция решающих деревьев

Добро пожаловать в третью статью курса «Основы Бэггинга». Мы уже прошли большой путь: разобрались с математикой бутстрэпа и изучили общий алгоритм бэггинга. Мы выяснили, что усреднение множества независимых моделей помогает снизить разброс (Variance) и победить переобучение.

Но в конце прошлой статьи мы столкнулись с проблемой. В реальной жизни добиться полной независимости моделей сложно. Если мы просто обучим 100 деревьев на бутстрэп-выборках, они часто получаются слишком похожими друг на друга. А усреднение похожих мнений не дает прироста качества.

Сегодня мы разберем алгоритм, который стал «золотым стандартом» в машинном обучении до эпохи нейросетей и бустинга. Это Случайный лес (Random Forest). Мы узнаем, как добавить в бэггинг еще больше случайности, чтобы сделать модели по-настоящему разными.

Проблема корреляции деревьев

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

Где: * — итоговый разброс (ошибка) ансамбля. * (ро) — корреляция между ошибками отдельных деревьев. * — дисперсия (ошибка) одного отдельного дерева. * — количество деревьев.

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

Почему деревья становятся похожими?

Представьте, что мы предсказываем вероятность выдачи кредита. В наших данных есть один очень мощный признак — «Наличие просрочек в прошлом». Есть и другие признаки (возраст, доход), но они слабее.

Когда мы строим решающие деревья, жадный алгоритм построения всегда ищет лучшее разбиение. Даже если мы используем разные бутстрэп-выборки, «Наличие просрочек» настолько сильный признак, что почти все деревья выберут его для самого первого, верхнего разбиения (корня дерева).

В результате:

Структура всех деревьев будет схожей.

Ошибки деревьев будут скоррелированы.

Эффективность бэггинга снизится.

Нам нужно заставить деревья быть разными. Нам нужно «запретить» им всегда выбирать самый очевидный путь.

!Иллюстрация того, как Случайный лес заставляет деревья быть структурно разными

Метод случайных подпространств (Random Subspace Method)

Лео Брейман, создатель Random Forest, предложил гениальное и простое решение. Чтобы декоррелировать деревья, нужно добавить случайность не только в выбор данных (строк), но и в выбор признаков (столбцов).

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

В Случайном лесе алгоритм меняется:

В каждом узле дерева, перед тем как выбрать разбиение, мы случайным образом выбираем подмножество из признаков (где ).

Лучшее разбиение ищется только среди этих признаков.

Остальные признаков в данном узле игнорируются.

Это изменение заставляет деревья использовать разные признаки. Если «Наличие просрочек» не попало в случайное подмножество , дерево будет вынуждено искать закономерности в «Доходе» или «Возрасте». Это делает деревья менее точными по отдельности (растет ), но зато они становятся очень разнообразными (сильно падает ). А так как падение влияет на формулу сильнее, общая ошибка ансамбля уменьшается.

Алгоритм Random Forest: шаг за шагом

Теперь мы можем сформулировать полный алгоритм Случайного леса. Пусть у нас есть обучающая выборка размером с признаками.

Инициализация: Выбираем количество деревьев и количество признаков для каждого разбиения .

Цикл по деревьям (от 1 до ):

* Бутстрэп: Создаем выборку размера с возвращением из исходных данных. * Построение дерева: Растим дерево на этой выборке, но с модификацией: * В каждом узле выбираем случайные признаков из . * Находим лучшее разбиение только среди этих . * Делим узел и повторяем процесс для дочерних узлов. * Важно: Деревья в лесу обычно строятся до максимальной глубины (без стрижки/pruning), чтобы обеспечить низкое смещение.

Агрегация:

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

Как выбрать гиперпараметр ?

Количество признаков (в библиотеке scikit-learn это параметр max_features) — это главный рычаг настройки Случайного леса.

* Если (берем все признаки), то Случайный лес превращается в обычный Бэггинг над деревьями. * Если , то дерево вообще не выбирает лучшее разбиение, а делит данные по случайно попавшемуся признаку.

На практике существуют эмпирические рекомендации (значения по умолчанию):

Для задач классификации:

Где: * — количество выбираемых признаков. * — общее количество признаков.

Для задач регрессии:

Эти значения обычно дают хороший баланс между разнообразием деревьев и их индивидуальной точностью.

Важность признаков (Feature Importance)

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

Существует два основных способа оценки важности:

1. MDI (Mean Decrease Impurity)

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

2. Permutation Importance (Перестановочная важность)

Этот метод работает уже после обучения:

Берем валидационную выборку и считаем точность модели.

Берем один признак (например, «Возраст») и случайно перемешиваем его значения в выборке (разрываем связь между признаком и целевой переменной).

Снова считаем точность модели на этих испорченных данных.

Если точность сильно упала — значит, признак был важен. Если почти не изменилась — значит, модель на него особо не смотрела.

Плюсы и минусы Случайного леса

Случайный лес долгое время был «королем» соревнований на Kaggle, пока не появился градиентный бустинг. Но он до сих пор остается отличным выбором для первого запуска (baseline).

Преимущества: * Высокая точность: Работает лучше одиночных алгоритмов и простого бэггинга. * Устойчивость к переобучению: Благодаря усреднению и декорреляции. * Работает «из коробки»: Гиперпараметры по умолчанию часто дают отличный результат, долгая настройка не требуется. * Оценка важности признаков: Помогает понять данные. * Нет необходимости в масштабировании: Деревьям все равно на масштаб признаков (не нужно делать StandartScaler).

Недостатки: * Медленное предсказание: Если в лесу 1000 глубоких деревьев, то для предсказания одного объекта нужно прогнать его через все 1000 деревьев. В реальном времени (Real-time) это может быть критично. * Размер модели: Лес может занимать сотни мегабайт памяти. * Слабость на экстраполяции: Как и любые деревья, лес не умеет предсказывать значения за пределами тех, что видел в обучающей выборке (например, если лес учился на ценах до 100 рублей, он не сможет предсказать 200).

Экстремально случайные деревья (Extra Trees)

Существует модификация алгоритма, называемая Extra Trees (Extremely Randomized Trees). В ней случайность доводится до абсолюта.

В обычном Random Forest мы выбираем случайное подмножество признаков, но внутри этого подмножества ищем оптимальный порог для разбиения (например, «Возраст > 25»). В Extra Trees мы выбираем случайное подмножество признаков, а затем для каждого из них выбираем случайный порог разбиения. Лучший из этих случайных вариантов становится узлом.

Это делает модель еще более быстрой в обучении и еще более устойчивой к шуму, хотя иногда и чуть менее точной.

Заключение

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

В этом курсе мы прошли путь от понимания «мудрости толпы» до построения сложных алгоритмов. Теперь вы знаете, что стоит за строчкой кода RandomForestClassifier() и почему этот метод настолько эффективен.

На этом наш курс по основам бэггинга завершен. Эти знания станут прочным фундаментом для изучения еще более сложных методов, таких как Градиентный бустинг.

Компромисс смещения и разброса: преимущества бэггинга в борьбе с переобучением

Мы уже изучили алгоритмы Бэггинга и Случайного леса, научились строить ансамбли и поняли, как работает бутстрэп. Но остался один фундаментальный вопрос: почему именно усреднение моделей улучшает результат? Почему сотня глубоких деревьев работает лучше, чем одно?

Ответ кроется в одной из самых важных концепций машинного обучения — компромиссе смещения и разброса (Bias-Variance Tradeoff). Понимание этого баланса отличает новичка, слепо запускающего fit/predict, от профессионала, понимающего природу ошибок своей модели.

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

Анатомия ошибки: Смещение, Разброс и Шум

Представьте, что обучение модели — это стрельба дротиками по мишени. Центр мишени (яблочко) — это истинная зависимость, скрытая в данных, которую мы хотим найти. Наши дротики — это предсказания модели.

Любая ошибка модели () складывается из трех компонентов:

Где: * — полная ошибка предсказания модели. * (Смещение) — ошибка, возникающая из-за упрощения модели. Она показывает, насколько среднее предсказание модели отклоняется от истины. * (Разброс) — ошибка, возникающая из-за чувствительности модели к малым изменениям в обучающих данных. Она показывает, насколько сильно меняется предсказание, если обучить модель на другой выборке. * (Шум) — неустранимая ошибка, связанная с качеством самих данных (ошибки измерения, скрытые факторы). Мы не можем на нее повлиять.

!Графическая иллюстрация понятий смещения и разброса на примере мишени для дартса

1. Смещение (Bias) — Проблема недообучения

Высокое смещение () означает, что модель слишком проста и не может уловить сложные закономерности в данных. Она «предвзята» и имеет свое жесткое мнение, игнорируя факты.

* Пример: Мы пытаемся описать траекторию полета ракеты прямой линией. Как бы мы ни старались, прямая линия никогда точно не опишет параболу. * Результат: Недообучение (Underfitting). Модель плохо работает и на обучающей, и на тестовой выборке. * Алгоритмы с высоким смещением: Линейная регрессия, логистическая регрессия, «пни» (деревья глубины 1).

2. Разброс (Variance) — Проблема переобучения

Высокий разброс () означает, что модель слишком сложна и чувствительна. Она пытается запомнить каждый отдельный пример из обучающей выборки, включая случайный шум.

* Пример: Студент перед экзаменом не учит общие принципы предмета, а зазубривает ответы на билеты прошлых лет. Если формулировка вопроса чуть изменится, он провалится. * Результат: Переобучение (Overfitting). Модель идеально работает на обучающей выборке (ошибка почти 0), но проваливается на тестовой. * Алгоритмы с высоким разбросом: Глубокие решающие деревья, k-ближайших соседей (при малом k), нейронные сети без регуляризации.

Компромисс (Tradeoff)

Проблема заключается в том, что уменьшение одного компонента ошибки часто приводит к увеличению другого.

* Делаем модель проще (уменьшаем глубину дерева) падает, но растет. * Делаем модель сложнее (увеличиваем глубину) падает, но растет.

Наша цель — найти «золотую середину», где сумма минимальна.

Бэггинг: Хирургическое удаление Разброса

Теперь самое интересное. Бэггинг (и Random Forest) — это уникальный метод, который позволяет снизить Разброс (Variance), не увеличивая Смещение (Bias).

Давайте разберем это математически. Пусть у нас есть независимых моделей .

Предположим, что каждая из этих моделей:

Имеет низкое смещение (мы используем глубокие деревья, которые хорошо подстраиваются под данные).

Имеет высокий разброс (каждое дерево сильно отличается от другого).

Предсказание ансамбля — это усреднение предсказаний базовых моделей:

Где: * — предсказание ансамбля. * — количество моделей. * — предсказание -й базовой модели.

Что происходит со смещением?

Смещение ансамбля равно среднему смещению базовых моделей. Если мы усредним 100 «умных» (низкое смещение), но нестабильных моделей, мы получим «умный» ответ.

Где: * — смещение всего ансамбля. * — смещение одной базовой модели.

Вывод: Бэггинг не портит точность модели. Если деревья были хорошими (недообученными), ансамбль тоже будет хорошим.

Что происходит с разбросом?

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

Где: * — разброс ансамбля. * — разброс одной базовой модели. * — количество моделей.

В реальности, как мы обсуждали в статье про Random Forest, модели не совсем независимы, поэтому формула сложнее:

Где: * — корреляция между моделями. * — дисперсия одной модели.

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

Почему для Бэггинга нужны «сильные» деревья?

Теперь вы можете ответить на вопрос, почему в Random Forest мы строим деревья до максимальной глубины и не стрижем их (no pruning).

Глубокое дерево имеет низкое смещение (оно выучило все детали), но очень высокий разброс (оно переобучено).

Бэггинг не умеет исправлять высокое смещение. Если мы возьмем 1000 плохих моделей (например, линейных регрессий для нелинейных данных), их усреднение все равно даст плохой результат. Усреднение ошибок одного знака не дает ноль.

Зато Бэггинг отлично исправляет высокий разброс. Усреднение случайных ошибок в разные стороны дает ноль.

Поэтому стратегия Бэггинга такова: > Возьми модели с минимальным смещением (пусть даже переобученные) и убей их разброс усреднением.

Визуализация эффекта

Представьте задачу классификации двух классов на плоскости, где граница между классами имеет сложную форму.

* Одиночное решающее дерево: Граница классов будет рваной, угловатой, с множеством странных выступов, пытающихся захватить отдельные точки-выбросы. Это высокий разброс. * Бэггинг (Random Forest): При наложении сотен таких рваных границ друг на друга и усреднении, итоговая разделяющая линия становится гладкой и плавной. Случайные выбросы игнорируются, так как большинство деревьев их не поддержит.

Когда Бэггинг НЕ поможет?

Бэггинг — мощный инструмент, но не серебряная пуля. Он бесполезен, если:

Базовые модели имеют высокое смещение. Усреднение «глупых» моделей (например, слишком коротких деревьев) не сделает их умнее. В этом случае лучше использовать Бустинг (который мы изучим в других курсах).

Данные слишком простые. Если зависимость линейная, то обычная линейная регрессия сработает лучше и быстрее, чем лес из 500 деревьев.

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

Заключение

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

Ошибка состоит из Смещения (Bias), Разброса (Variance) и Шума.

Сложные модели страдают от высокого Разброса (переобучения).

Бэггинг уменьшает Разброс путем усреднения, сохраняя низкое Смещение базовых моделей.

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

Этим мы завершаем теоретический блок курса. Вы обладаете полным набором знаний: от математики бутстрэпа до тонкостей Bias-Variance Tradeoff. Теперь вы готовы применять эти знания осознанно, понимая каждое движение внутри «черного ящика» алгоритма.

Практическая реализация бэггинга и настройка гиперпараметров на Python

Поздравляем! Вы прошли теоретический путь от основ бутстрэпа до тонкостей компромисса смещения и разброса. Теперь вы понимаете, почему ансамбли работают лучше одиночных моделей и какая математика стоит за «мудростью толпы».

В этой финальной статье курса мы перейдем от теории к практике. Мы научимся реализовывать алгоритмы Бэггинга и Случайного леса с помощью самой популярной библиотеки машинного обучения — scikit-learn. Мы разберем ключевые гиперпараметры, научимся оценивать качество моделей без отложенной выборки (OOB) и визуализировать важность признаков.

Подготовка окружения и данных

Для работы нам понадобится библиотека scikit-learn. Если она у вас еще не установлена, это можно сделать через pip:

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

Реализация классического Бэггинга

В scikit-learn классический бэггинг реализован в классах BaggingClassifier (для классификации) и BaggingRegressor (для регрессии).

Как мы помним из второй статьи, бэггинг — это мета-алгоритм. Это значит, что он принимает на вход другую модель (базовый эстиматор) и оборачивает её в ансамбль.

Создание ансамбля

Давайте создадим бэггинг над решающими деревьями.

Разбор ключевых параметров

* estimator: Модель, которую мы будем размножать. По умолчанию это DecisionTreeClassifier, но вы можете поставить туда что угодно, например, KNeighborsClassifier или логистическую регрессию (хотя для стабильных моделей бэггинг менее эффективен). * n_estimators: Количество базовых моделей (). Чем больше, тем стабильнее результат, но дольше обучение. Обычно значения от 50 до 500 достаточно. * max_samples: Какую долю выборки брать для обучения одной модели. Обычно оставляют 1.0 (размер бутстрэп-выборки равен размеру исходной). * bootstrap: Если True, выборка делается с возвращением (классический бэггинг). Если False, выборка делается без возвращения (этот метод называется Pasting). * n_jobs: Параметр параллелизма. Значение -1 задействует все доступные ядра процессора, что критически важно для ускорения обучения больших ансамблей.

Out-of-Bag (OOB) оценка

В первой статье мы математически доказали, что при бутстрэпе около 36.8% данных не попадают в обучающую выборку конкретного дерева. Эти данные называются Out-of-Bag. Мы можем использовать их для валидации модели прямо в процессе обучения, не используя отдельный X_test.

Чтобы включить этот режим, нужно установить параметр oob_score=True.

Обычно oob_score_ очень близок к реальной точности на тестовой выборке. Это позволяет экономить данные: если данных мало, можно не выделять валидационный набор, а доверять OOB-оценке.

Случайный лес (Random Forest)

Хотя BaggingClassifier универсален, для деревьев решений существует специализированный и более оптимизированный класс — RandomForestClassifier (или RandomForestRegressor).

Главное отличие, как мы помним, заключается в декорреляции: Случайный лес выбирает случайное подмножество признаков при каждом разбиения узла, а не один раз для всего дерева.

Важнейший параметр: max_features

В RandomForestClassifier параметр max_features управляет разнообразием деревьев.

* Если max_features равен общему числу признаков, лес превращается в обычный бэггинг. * По умолчанию для классификации используется sqrt (квадратный корень из числа признаков), а для регрессии — 1.0 (все признаки) или log2. * Уменьшение max_features увеличивает разнообразие деревьев (снижает корреляцию), что помогает бороться с переобучением, но может слегка увеличить смещение.

Настройка гиперпараметров

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

Вспомним теорию Bias-Variance:

Нам нужны сложные деревья (низкое смещение), поэтому max_depth должен быть большим.

Нам нужно много деревьев, чтобы усреднить разброс.

Советы по настройке: * n_estimators: Увеличивайте, пока хватает терпения и памяти. Качество растет асимптотически и выходит на плато. Переобучиться из-за большого количества деревьев в лесу практически невозможно. * max_depth: Обычно None (без ограничений) работает хорошо. Если модель слишком тяжелая, можно ограничить глубину (например, 10-20). * min_samples_leaf: Увеличение этого параметра (например, до 3-5) сглаживает модель и уменьшает размер деревьев, работая как регуляризация.

Анализ важности признаков (Feature Importance)

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

!Визуализация важности признаков, полученная из модели Random Forest

Этот метод (MDI) рассчитывается на основе того, как часто признак использовался для разбиения и насколько сильно он снижал загрязненность (Gini/Entropy). Это позволяет отбросить мусорные признаки и упростить модель.

Заключение курса

Мы завершили курс «Основы Бэггинга в машинном обучении». Давайте подведем итоги нашего пути:

Теория: Мы узнали, что бэггинг снижает разброс (Variance) модели, не увеличивая её смещение (Bias). Это достигается за счет усреднения множества независимых моделей.

Математика: Мы разобрали метод бутстрэпа и правило 63.2%, которое объясняет формирование обучающих выборок.

Алгоритмы: Мы изучили эволюцию от простого бэггинга к Случайному лесу, где добавляется случайный выбор признаков для декорреляции деревьев.

Практика: Сегодня мы научились применять эти знания на Python, настраивать гиперпараметры и анализировать важность признаков.

Бэггинг и Случайный лес — это надежные «рабочие лошадки» Data Science. Они устойчивы к выбросам, не требуют сложной предобработки данных (масштабирования) и дают отличные результаты «из коробки». Теперь эти мощные инструменты находятся в вашем арсенале.

Удачи в ваших будущих проектах и экспериментах с данными!