Задание 3.1 и 3.2 · 3 балла за класс

Градиентный бустинг и синус

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

Бустинг

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

Пенёк, неглубокое дерево

Дерево глубины 1-3. Само по себе слабое, зато не переобучается.

f₀

Начальный прогноз: одна константа для всех, у нас среднее y.

Остатки r

Антиградиент потерь. Для MSE это 2(y - f): удвоенная текущая ошибка.

ρ (ро)

Длина шага: с каким множителем прибавить новое дерево.

Алгоритм

Код

class GradientTreeBoosting:
    def __init__(self, loss='MSE', iterations=10, const_p=False, **tree_kwargs):
        self.loss, self.loss_gradient = losses[loss]
        self.iterations = iterations
        self.const_p = const_p
        self.tree_kwargs = tree_kwargs
        self.trees = []
        self.rhos = []
        self.train_loss = []

1. losses[loss] из словаря берём пару (функция потерь, её градиент) по названию 'MSE', 'MAE' или 'lq'.
2. const_p True: ρ всегда 1. False: ρ подбирается каждый шаг.
3. **tree_kwargs всё остальное (max_depth=3, random_state=42) уходит в DecisionTreeRegressor.
4. trees, rhos список обученных деревьев и их шагов, это и есть модель. train_loss история ошибки для графика.

    def fit(self, X, y):
        y = np.asarray(y, dtype=float)
        self.f0 = np.mean(y)
        f = np.full(len(y), self.f0)
        self.trees, self.rhos, self.train_loss = [], [], []
        rho_grid = np.linspace(-1, 1, 201)
        for _ in range(self.iterations):
            residuals = -self.loss_gradient(y, f)
            tree = DecisionTreeRegressor(**self.tree_kwargs).fit(X, residuals)
            h = tree.predict(X)
            if self.const_p:
                rho = 1.0
            else:
                rho = rho_grid[np.argmin(self.loss(y, f + rho_grid[:, None] * h))]
            f = f + rho * h
            self.trees.append(tree)
            self.rhos.append(rho)
            self.train_loss.append(self.loss(y, f))
        return self

1. np.full(len(y), self.f0) массив, где у всех объектов прогноз = среднее.
2. np.linspace(-1, 1, 201) 201 кандидат ρ с шагом 0.01: условие просит брать ρ из чисел от -1 до 1.
3. residuals = -self.loss_gradient(y, f) антиградиент: куда двигать прогноз каждого объекта.
4. DecisionTreeRegressor(...).fit(X, residuals) дерево учится предсказывать не y, а остатки.
5. rho_grid[:, None] * h матрица 201 × n: строка k это прогноз f + ρₖ·h. self.loss(...) благодаря axis=-1 даёт 201 число, np.argmin номер лучшего. Всё без цикла по ρ.
6. f = f + rho * h обновляем прогноз.

    def predict(self, X):
        f = np.full(len(X), self.f0)
        for tree, rho in zip(self.trees, self.rhos):
            f = f + rho * tree.predict(X)
        return f

1. Начинаем с константы и по очереди прибавляем вклад каждого дерева, как требует условие («последовательно применить»).

Синус

Подбор ρ каждый раз выбрал ρ = 0.5. Ошибка 0.026 близка к шуму: 0.2² = 0.04, лучше на этих точках почти нельзя.

Попробуй руками

Тот же бустинг деревьями глубины 3 на синусе. Нажимай «Шаг» и смотри, как жёлтая линия приближается к синусу. Потом переключи режим на «ρ = 1» и сравни: линия начинает метаться.

Вопросы на защите