Какие алгоритмы могут дать отрицательное значение предсказания при y > 0?

Алгоритмы, предсказывающие отрицательные значения при положительных целевых переменных

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

1. Линейная регрессия

Классический пример алгоритма, который может предсказать отрицательное значение.

Почему это происходит: Линейная регрессия моделирует линейную зависимость: ŷ = b₀ + b₁x₁ + b₂x₂ + ... + bₙxₙ

При достаточно малых значениях признаков или при отрицательном свободном члене b₀, модель предсказывает отрицательные значения.

import numpy as np
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt

# Генерируем данные (все y > 0)
X = np.array([[1], [2], [3], [4], [5]])
y = np.array([0.5, 1.5, 2.5, 3.5, 4.5])

model = LinearRegression()
model.fit(X, y)

print(f'Коэффициент: {model.coef_[0]:.3f}')
print(f'Свободный член: {model.intercept_:.3f}')

# Предсказание для x=0
prediction_at_zero = model.predict([[0]])[0]
print(f'Предсказание при x=0: {prediction_at_zero:.3f}')
# Результат: предсказание отрицательное!

# Визуализация
plt.figure(figsize=(10, 6))
plt.scatter(X, y, color='blue', s=100, label='Реальные данные')
x_range = np.linspace(-1, 6, 100).reshape(-1, 1)
y_pred = model.predict(x_range)
plt.plot(x_range, y_pred, 'r-', linewidth=2, label='Линия регрессии')
plt.axhline(y=0, color='black', linestyle='--', alpha=0.3)
plt.axvline(x=0, color='black', linestyle='--', alpha=0.3)
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Линейная регрессия предсказывает отрицательные значения')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

2. Полиномиальная регрессия

Ещё более подвержена предсказанию отрицательных значений, особенно на краях диапазона.

from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline

# Полиномиальная регрессия степени 3
pipeline = Pipeline([
    ('poly', PolynomialFeatures(degree=3)),
    ('linear', LinearRegression())
])

pipeline.fit(X, y)
y_pred_poly = pipeline.predict(x_range)

# На краях полиноми могут быть отрицательными
print(f'Минимальное предсказание: {y_pred_poly.min():.3f}')

3. SVM (Support Vector Regression) с линейным ядром

from sklearn.svm import SVR

model = SVR(kernel='linear')
model.fit(X, y)

# Может предсказать отрицательные значения
y_pred = model.predict(x_range)
print(f'Содержит отрицательные предсказания: {(y_pred < 0).any()}')

4. Нейронные сети без ограничений

import torch
import torch.nn as nn
from torch.optim import Adam

class NeuralNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(1, 10)
        self.fc2 = nn.Linear(10, 1)
    
    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)  # Без ограничения! Может быть отрицательным
        return x

model = NeuralNet()
# После обучения может предсказать отрицательные значения для новых данных

5. Деревья решений (менее часто)

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

Решения

Способ 1: Трансформация целевой переменной

Логарифмическая трансформация

Если y > 0, используем: ŷ = log(y)

Тогда модель предсказывает log(y), и после exp() получаем положительные значения.

from sklearn.compose import TransformedTargetRegressor

model = TransformedTargetRegressor(
    regressor=LinearRegression(),
    func=np.log,
    inverse_func=np.exp
)

model.fit(X, y)
y_pred = model.predict(X)  # Всегда положительные!

Квадратичная трансформация

Если нужны только положительные: ŷ = y²

Способ 2: Использование правильной функции активации

В нейронных сетях

class NeuralNetPositive(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc1 = nn.Linear(1, 10)
        self.fc2 = nn.Linear(10, 1)
    
    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))  # ReLU гарантирует ≥ 0
        # или используем exp() для строго положительных
        # x = torch.exp(self.fc2(x))
        return x

Способ 3: Post-processing (пост-обработка)

Clip (обрезание)

y_pred = model.predict(X)
y_pred_clipped = np.maximum(y_pred, 0)  # Отрицательные -> 0

Недостатки: теряем информацию, может быть смещение предсказаний.

Max c малым значением

y_pred_clipped = np.maximum(y_pred, 1e-6)  # Минимум 0.000001

Способ 4: Правильная функция ошибки

Использование Loss функции, которая штрафует отрицательные предсказания

def custom_loss(y_true, y_pred):
    # Штрафуем за отрицательные предсказания
    penalty = torch.sum(torch.relu(-y_pred))
    mse = torch.mean((y_true - y_pred) ** 2)
    return mse + 10 * penalty

Способ 5: Использование специализированных моделей

Регрессия на основе Пуассона (для счётных данных)

from sklearn.linear_model import PoissonRegressor

model = PoissonRegressor()  # Гарантирует положительные предсказания
model.fit(X, y)
y_pred = model.predict(X)  # Всегда > 0

Гамма регрессия (для положительных непрерывных данных)

from sklearn.linear_model import GammaRegressor

model = GammaRegressor()
model.fit(X, y)
y_pred = model.predict(X)  # Всегда > 0

XGBoost с задачей регрессии на положительные значения

import xgboost as xgb

model = xgb.XGBRegressor(objective='reg:gamma')  # Gamma regression
model.fit(X, y)
y_pred = model.predict(X)  # Гарантирует положительные

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

1. Для счётных данных (0, 1, 2, ...): используйте PoissonRegressor
2. Для положительных непрерывных: используйте GammaRegressor или логарифмическую трансформацию
3. Для нейросетей: используйте ReLU или exp() в выходном слое
4. Для линейной регрессии: используйте TransformedTargetRegressor с log/exp
5. В худшем случае: используйте post-processing с np.maximum()

Проверка результатов

y_pred = model.predict(X)
print(f'Минимальное предсказание: {y_pred.min():.6f}')
print(f'Есть ли отрицательные: {(y_pred < 0).any()}')
print(f'MAE на ошибках предсказания: {np.mean(np.abs(y_pred - y)):.3f}')

Выбор решения зависит от природы данных и задачи, но помните: если y всегда > 0, модель должна это гарантировать.