Теория
Регресия (regression) е задача, в която предсказваме число: цена на апартамент по площта, точки на тест по часовете учене, спирачен път по скоростта. Най-простият модел е права y = a * x + b: a е наклонът (slope, coefficient) – с колко расте y, когато x се увеличи с единица, а b е свободният член (intercept) – стойността при x = 0. За всяка точка от данните разликата между истинската стойност и прогнозата се нарича остатък (residual): e = y - (a * x + b). Обикновеният сбор на остатъците не е добра мярка – положителните и отрицателните се унищожават взаимно. Затова методът на най-малките квадрати (least squares) избира a и b така, че сумата на квадратите на остатъците да е най-малка. Квадратът премахва знака, наказва силно големите грешки и има гладка форма, която позволява точно, аналитично решение.
Как се намира минимумът? Сумата на квадратите е функция на a и b; там, където е най-малка, частните ѝ производни по a и по b са нула. От тези две уравнения следват готови формули: a = Σ(x - x̄)(y - ȳ) / Σ(x - x̄)² и b = ȳ - a * x̄, където x̄ и ȳ са средните стойности. Оттук следва и едно хубаво свойство: правата по най-малки квадрати винаги минава през точката на средните (x̄, ȳ). При повече признаци подреждаме всички в матрица X (с колона от единици за свободния член) и решението е нормалното уравнение (Xᵀ X) β = Xᵀ y, което в numpy се решава с np.linalg.solve(X.T @ X, X.T @ y) или направо с np.linalg.lstsq. Точно това прави и LinearRegression отвътре – само че по численно по-стабилен път.
В практиката не пишем формулите на ръка – линейната регресия със scikit-learn е няколко реда. Създаваме модел model = LinearRegression(), обучаваме го с model.fit(X, y) и прогнозираме с model.predict(X_new). Намерените параметри са в model.coef_ (масив с по един наклон за всеки признак) и model.intercept_. Важно изискване: X трябва да е двумерен масив с форма (брой примери, брой признаци) – дори при един признак пишем x.reshape(-1, 1), иначе fit хвърля ValueError. За честна оценка първо разделяме данните с train_test_split(X, y, test_size=0.3, random_state=0): обучаваме върху обучаващото множество (training set) и мерим грешката върху валидационното множество (validation set), което моделът не е виждал.
Доколко е добър моделът, казват метриките – всички се изчисляват от остатъците, най-честно върху валидационните данни. MAE (mean absolute error, mean_absolute_error) е средната абсолютна грешка – „средно бъркаме с толкова“, в същите единици като y. MSE (mean squared error, mean_squared_error) е средният квадрат на грешката – с точност до делене на броя точки това е величината, която най-малките квадрати минимизират, но е в „квадратни“ единици. RMSE (root_mean_squared_error) е коренът от MSE: връща се в единиците на y и наказва големите грешки по-силно от MAE. R² (коефициент на детерминация, r2_score или model.score(X, y)) показва каква част от разсейването на y обяснява моделът: 1 означава идеално, 0 – не по-добре от прогноза „винаги средната стойност“, а може да бъде и отрицателен, когато моделът е по-лош от средната. Сравнявайте метрики само между модели върху едни и същи данни.
Много зависимости не са прави линии: спирачният път расте с квадрата на скоростта, температурата през деня се вдига и спада, растежът на популация се забавя при насищане. Полиномната (нелинейна) регресия моделира такива криви с полином y = b + a1*x + a2*x² + ... + ad*x^d, където d е степента (degree). Трикът е, че моделът е нелинеен по x, но линеен по параметрите a1 ... ad – ако приемем x², x³ за отделни нови признаци, задачата отново е линейна регресия и пак се решава с най-малките квадрати. При два признака степен 2 добавя освен квадратите и взаимодействието x1*x2. Колкото по-висока е степента, толкова по-гъвкава е кривата – и толкова по-лесно тя започва да следва шума вместо закономерността.
В scikit-learn новите признаци ги прави PolynomialFeatures(degree=d, include_bias=False): от колона x той създава x, x², ..., x^d (с include_bias=True добавя и колона от единици, която е излишна, защото LinearRegression има собствен свободен член). Най-чистият начин е да го свържем с регресията в конвейер (Pipeline): model = make_pipeline(PolynomialFeatures(degree=3, include_bias=False), LinearRegression()). След това model.fit(X_train, y_train) и model.predict(X_val) работят със суровия X – конвейерът сам прилага преобразуването на всяко място, така че не можете да забравите да трансформирате валидационните данни. Отделните стъпки са достъпни през model.named_steps['linearregression'].coef_. За да нарисувате кривата, прогнозирайте върху гъста мрежа np.linspace(x_min, x_max, 200).reshape(-1, 1) и подайте резултата на plt.plot.
Сега най-важният урок: преобучението (overfitting). Полином от степен 15 през няколко десетки точки минава почти през всяка от тях – грешката върху обучаващите данни е нищожна – но между точките и по краищата кривата се мята диво и прогнозите за нови данни са ужасни. Обратното е недообучението (underfitting): права през синусоида има голяма грешка и на обучаващите, и на новите данни. Зад двете стои компромисът отклонение–дисперсия (bias–variance tradeoff): простият модел е „предубеден“ (голямо отклонение – не може да улови формата), сложният е „нервен“ (голяма дисперсия – друга извадка от същите данни би дала съвсем друга крива). Инструментът за избор на степента е кривата на валидация: обучаваме модели със степени 1, 2, 3, ... и чертаем RMSE върху обучаващото и върху валидационното множество. Обучаващата грешка практически само намалява със степента, а валидационната първо пада, после расте – избираме степента в минимума на валидационната крива, а не тази с най-ниска обучаваща грешка.
Златни правила
Оценявай върху данни, които моделът не е виждал
Грешката върху обучаващото множество винаги е оптимистична и само намалява, когато моделът става по-сложен. Разделете данните с train_test_split и вземайте решения (степен, избор между модели) само по валидационната грешка.
X е винаги двумерен
fit и predict очакват форма (примери, признаци). Един признак е x.reshape(-1, 1), а една нова точка е [[7.5]] – не 7.5.
Степента я избира валидационната крива, не окото
Чертайте RMSE за обучение и за валидация при степени 1, 2, 3, ... и взимайте степента в минимума на валидационната крива. Ако две степени са почти равни, предпочитайте по-ниската – по-простият модел е по-стабилен.
PolynomialFeatures живее в Pipeline
С make_pipeline(PolynomialFeatures(...), LinearRegression()) преобразуването се прилага автоматично и при fit, и при predict, и при кръстосана валидация. Ръчното fit_transform рано или късно води до забравен валидационен набор и ValueError.
Чети метриката в единиците на задачата
MAE и RMSE са в единиците на y (евро, метри, точки): RMSE от 5 m при спирачен път означава нещо, RMSE от 5 без единици – нищо. R² е безразмерен и казва каква част от разсейването е обяснена; сравнявайте го само между модели върху едни и същи данни.
Бърз справочник
Метрики за регресия
| Метрика | Функция в scikit-learn | Какво измерва | Как се чете |
|---|---|---|---|
| MAE | mean_absolute_error(y, y_pred) | Средна абсолютна грешка, в единиците на y | „Средно бъркаме с толкова“; по-малко е по-добре |
| MSE | mean_squared_error(y, y_pred) | Среден квадрат на грешката, в квадратни единици | Величината, която най-малките квадрати минимизират; трудна за четене директно |
| RMSE | root_mean_squared_error(y, y_pred) | Корен от MSE, в единиците на y | Като MAE, но големите грешки тежат повече; сравнявайте с мащаба на y |
| R² | r2_score(y, y_pred) | Дял от разсейването на y, обяснен от модела | 1 = идеално, 0 = колкото прогноза „средната“, под 0 = по-зле от средната |
| R² през модела | model.score(X, y) | Същото като r2_score, но моделът сам прогнозира | Удобно за бърза проверка; при Pipeline се подава суровият X |
| Остатък | y - model.predict(X) | Грешка за всяка отделна точка | Големи остатъци = точки, които моделът не обяснява; гледайте ги на графика |
| Сума на квадратите (SSE) | np.sum((y - y_pred) ** 2) | Общата „цена“, която най-малките квадрати минимизират | Намалява с всеки добавен признак или степен; не я ползвайте за избор на модел |
Диагностика: недообучение, добър модел, преобучение
| Признак | Недообучение | Добър модел | Преобучение |
|---|---|---|---|
| Грешка на обучение | Висока | Ниска | Много ниска, почти 0 |
| Грешка на валидация | Висока, близка до обучаващата | Ниска, малко над обучаващата | Висока, многократно над обучаващата |
| Как изглежда кривата | Твърде проста, не следва формата (права през синусоида) | Следва общата форма, игнорира шума | Минава през всяка точка, мята се между тях и по краищата |
| Степен на полинома | Твърде ниска | Около минимума на валидационната крива | Твърде висока спрямо броя точки |
| Отклонение / дисперсия | Голямо отклонение (bias) | Балансирани | Голяма дисперсия (variance) |
| R² на валидация | Нисък (например 0.3) | Висок и близък до обучаващия | Много по-нисък от обучаващия, понякога отрицателен |
| Какво да направим | Повишете степента или добавете признаци | Спрете тук и запазете модела | Намалете степента, съберете повече данни или добавете регуляризация (Ridge) |
Код за анализ и пренаписване
Най-малки квадрати по три начина и метрики
import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, mean_squared_error, root_mean_squared_error, r2_score
# Часове учене (x) и точки на тест (y) за 8 ученици
x = np.array([1, 2, 3, 4, 5, 6, 7, 8], dtype=float)
y = np.array([52, 55, 61, 64, 70, 74, 77, 85], dtype=float)
# 1) Най-малки квадрати "на ръка" по формулите за наклон и свободен член
x_mean, y_mean = x.mean(), y.mean()
a = np.sum((x - x_mean) * (y - y_mean)) / np.sum((x - x_mean) ** 2)
b = y_mean - a * x_mean
print(f"На ръка: y = {a:.3f} * x + {b:.3f}")
# 2) Нормално уравнение: (X^T X) beta = X^T y
X_design = np.column_stack([np.ones_like(x), x]) # колона от единици + колона x
beta = np.linalg.solve(X_design.T @ X_design, X_design.T @ y)
print(f"Нормално ур.: y = {beta[1]:.3f} * x + {beta[0]:.3f}")
# 3) Същото със scikit-learn
X = x.reshape(-1, 1) # 2D масив: 8 реда (примери), 1 колона (признак)
model = LinearRegression()
model.fit(X, y)
print(f"scikit-learn: y = {model.coef_[0]:.3f} * x + {model.intercept_:.3f}")
# 4) Остатъци и метрики
y_pred = model.predict(X)
residuals = y - y_pred
print("Остатъци:", np.round(residuals, 2))
print(f"Сума на квадратите на остатъците: {np.sum(residuals ** 2):.2f}")
print(f"MAE = {mean_absolute_error(y, y_pred):.3f}")
print(f"MSE = {mean_squared_error(y, y_pred):.3f}")
print(f"RMSE = {root_mean_squared_error(y, y_pred):.3f}")
print(f"R^2 = {r2_score(y, y_pred):.3f}")
print(f"model.score(X, y) = {model.score(X, y):.3f}")
# 5) Прогноза за нов ученик
new_hours = np.array([[9.5]])
print(f"Прогноза за 9.5 часа учене: {model.predict(new_hours)[0]:.1f} точки")Какво се случва тук?
- Данните са два едномерни масива:
x– часове учене,y– точки на теста. Формулата за наклонаaдели „съвместното отклонение“ наxиyот средните им на разсейването наx, аb = y_mean - a * x_meanгарантира, че правата минава през точката на средните. -
X_design = np.column_stack([np.ones_like(x), x])строи матрицата на дизайна с колона от единици за свободния член.np.linalg.solve(X_design.T @ X_design, X_design.T @ y)решава нормалното уравнение(Xᵀ X) β = Xᵀ y;beta[0]еb,beta[1]еa. -
LinearRegression().fit(X, y)иска двумеренX, затоваx.reshape(-1, 1)превръща 8 числа в 8 реда по 1 колона. И трите подхода даватy = 4.595 * x + 46.571– сами се убеждавате, че scikit-learn прави същите най-малки квадрати, а не някаква друга магия. -
residuals = y - y_predса остатъците; те имат различни знаци и сумата им е практически 0 – това е свойство на всяко решение по най-малки квадрати със свободен член. Сумата на квадратите им (8.62) е точно величината, която беше минимизирана. -
mean_absolute_error(0.90 точки) иroot_mean_squared_error(1.04 точки) са в единиците наy;mean_squared_error(1.08) е в „точки на квадрат“ и затова се чете по-трудно.r2_score= 0.990 казва, че 99% от разликите между учениците се обясняват с часовете учене;model.score(X, y)връща същото число. - Прогнозата за нов ученик се подава пак като двумерен масив
np.array([[9.5]]);predictвръща масив, затова взимаме[0]. Внимание: 9.5 часа е извън диапазона на данните (1–8), а екстраполацията е най-ненадеждната прогноза на всеки регресионен модел.
Полиноми от степен 1, 3 и 15: кой се преобучава?
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.pipeline import make_pipeline
from sklearn.metrics import root_mean_squared_error
# Изкуствени данни: истинската зависимост е синусоида + случаен шум
rng = np.random.default_rng(68)
X = rng.uniform(0, 1, 40).reshape(-1, 1)
y = np.sin(2 * np.pi * X[:, 0]) + rng.normal(0, 0.25, 40)
# Делим на обучаващо и валидационно множество
X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.3, random_state=0)
degrees = [1, 3, 15]
x_grid = np.linspace(0, 1, 200).reshape(-1, 1) # гъста мрежа за чертане на кривата
plt.figure(figsize=(12, 4))
for i, d in enumerate(degrees, start=1):
model = make_pipeline(PolynomialFeatures(degree=d, include_bias=False), LinearRegression())
model.fit(X_train, y_train)
rmse_train = root_mean_squared_error(y_train, model.predict(X_train))
rmse_val = root_mean_squared_error(y_val, model.predict(X_val))
print(f"степен {d:2d}: RMSE обучение = {rmse_train:.3f} RMSE валидация = {rmse_val:.3f}")
plt.subplot(1, 3, i)
plt.scatter(X_train, y_train, label="обучение")
plt.scatter(X_val, y_val, marker="x", label="валидация")
plt.plot(x_grid, model.predict(x_grid), color="red", label=f"полином, степен {d}")
plt.ylim(-2, 2)
plt.title(f"Степен {d}")
plt.legend()
plt.tight_layout()
plt.savefig("polynomial_fits.png")
plt.show()Какво се случва тук?
-
np.random.default_rng(68)е съвременният генератор на случайни числа в numpy; с фиксирано зърно всеки получава едни и същи 40 точки. Истинската зависимост еsin(2πx), аrng.normal(0, 0.25, 40)добавя шум – в реалните данни шумът винаги го има, просто не знаем формулата. -
train_test_split(..., test_size=0.3, random_state=0)заделя 12 точки за валидация, които нито един от трите модела не вижда приfit. -
make_pipeline(PolynomialFeatures(degree=d, include_bias=False), LinearRegression())е целият модел: първата стъпка прави признацитеx, x², ..., x^d, втората намира коефициентите по най-малки квадрати.fitиpredictполучават суровияX_train– конвейерът преобразува сам. - Отпечатаните числа са диагнозата: степен 1 – RMSE 0.42 на обучение и 0.60 на валидация (и двете високи – недообучение); степен 3 – 0.20 и 0.24 (ниски и близки – добър модел); степен 15 – 0.16 на обучение, но 1.18 на валидация (седем пъти по-зле на нови данни – преобучение).
-
x_grid = np.linspace(0, 1, 200).reshape(-1, 1)е гъста мрежа от точки само за чертане:model.predict(x_grid)дава гладка крива, а не прогнози само в наличните точки.plt.subplot(1, 3, i)слага трите графики една до друга, аplt.ylim(-2, 2)ги прави сравними. - На графиката полиномът от степен 15 се „гмурка“ под -2 в левия край, където има малко точки – типичното поведение на преобучен полином по краищата на диапазона.
plt.savefigсе вика предиplt.show(): след затваряне на прозореца фигурата вече я няма иsavefigби записал празна картинка.
Внимавай! Чести грешки
Грешките, които почти всеки прави в тази тема — виж разликата между грешния и правилния код.
Едномерен X при fit
Грешно
x = np.array([1, 2, 3, 4, 5])
y = np.array([2, 4, 6, 8, 10])
model = LinearRegression()
model.fit(x, y) # ValueError: Expected 2D array, got 1D array insteadПравилно
x = np.array([1, 2, 3, 4, 5])
y = np.array([2, 4, 6, 8, 10])
X = x.reshape(-1, 1) # 5 реда (примери), 1 колона (признак)
model = LinearRegression()
model.fit(X, y)
print(model.predict([[6]])) # и новата точка е двумерна -> [12.]scikit-learn очаква таблица с форма (примери, признаци), а едномерният масив е двусмислен – 5 примера с 1 признак или 1 пример с 5 признака? reshape(-1, 1) казва „колкото реда трябва, една колона“; същото важи и за точката, която подавате на predict.
Избор на степен по грешката на обучение
Грешно
scores = {}
for d in range(1, 16):
model = make_pipeline(PolynomialFeatures(d, include_bias=False), LinearRegression())
model.fit(X, y)
scores[d] = model.score(X, y) # R² върху същите данни, с които е обучен
best = max(scores, key=scores.get) # почти винаги най-високата степенПравилно
X_tr, X_val, y_tr, y_val = train_test_split(X, y, test_size=0.3, random_state=0)
scores = {}
for d in range(1, 16):
model = make_pipeline(PolynomialFeatures(d, include_bias=False), LinearRegression())
model.fit(X_tr, y_tr)
scores[d] = model.score(X_val, y_val) # R² върху невиждани данни
best = max(scores, key=scores.get)Обучаващата грешка само намалява с добавянето на степени, затова „най-добрият“ по нея модел е най-сложният – и най-преобученият. Решението за степента трябва да идва от валидационни данни: върху същите 40 зашумени точки от синусоида обучаващият R² сочи степен 14, а валидационният – степен 3.
Ръчен PolynomialFeatures и забравен валидационен набор
Грешно
poly = PolynomialFeatures(degree=3, include_bias=False)
X_train_poly = poly.fit_transform(X_train)
model = LinearRegression().fit(X_train_poly, y_train)
y_pred = model.predict(X_test)
# ValueError: X has 1 features, but LinearRegression is expecting 3 features as input.Правилно
model = make_pipeline(PolynomialFeatures(degree=3, include_bias=False), LinearRegression())
model.fit(X_train, y_train) # конвейерът преобразува X_train сам
y_pred = model.predict(X_test) # ... и X_test също, със същата степенМоделът е обучен върху 3 признака (x, x², x³), а получава суров X_test с 1 признак. Може да се поправи с poly.transform(X_test), но Pipeline премахва самата възможност за грешката и работи правилно и с cross_val_score.
mean_squared_error(squared=False) в нов scikit-learn
Грешно
from sklearn.metrics import mean_squared_error
rmse = mean_squared_error(y_test, y_pred, squared=False)
# TypeError: got an unexpected keyword argument 'squared' (scikit-learn 1.6+)Правилно
from sklearn.metrics import mean_squared_error, root_mean_squared_error
rmse = root_mean_squared_error(y_test, y_pred) # scikit-learn 1.4+
rmse_old = np.sqrt(mean_squared_error(y_test, y_pred)) # работи във всяка версияМного стари уроци и отговори в интернет използват squared=False, но параметърът е обявен за остарял в scikit-learn 1.4 и премахнат в 1.6. Използвайте root_mean_squared_error или просто корен от MSE – двете дават едно и също число.
Задачи за самостоятелна работа
Опитай първо сам — подсказката е там само ако наистина закъсаш.
Задача 1: Цена на апартамент по площ
Дадени са площите (кв. м) и цените (хиляди евро) на 9 апартамента: площ 45, 52, 60, 68, 75, 83, 90, 105, 120, цена 68, 75, 86, 95, 104, 118, 125, 146, 170. Сметнете наклона и свободния член „на ръка“ по формулите на най-малките квадрати, после обучете LinearRegression и сравнете. Отпечатайте уравнението на правата, колко евро струва всеки допълнителен квадратен метър, MAE, RMSE и R², и прогнозирайте цената на апартамент от 78 кв. м.
Задача 2: Спирачен път – права или парабола?
Измерен е спирачният път (m) при скорости 20, 30, ..., 120 km/h: 6.5, 11.4, 17.6, 25.8, 34.1, 44.3, 55.2, 68.7, 81.9, 96.5, 112.8. Разделете данните с train_test_split(test_size=0.3, random_state=1), обучете два конвейера – с PolynomialFeatures от степен 1 и от степен 2 – и сравнете R² и RMSE върху тестовите данни. Отпечатайте коефициентите на всеки модел и с по-добрия, обучен върху всички данни, прогнозирайте спирачния път при 130 km/h.
Задача 3: Крива на валидация и избор на степен
Генерирайте 35 точки с rng = np.random.default_rng(61): x равномерно в [-2, 2], y = 0.5x³ - 2x + шум, където шумът е rng.normal(0, 1.5, 35). Разделете ги 70/30 с random_state=0. За всяка степен от 1 до 12 обучете конвейер PolynomialFeatures + LinearRegression и запишете RMSE върху обучаващото и върху валидационното множество. Отпечатайте таблица, изберете автоматично степента с най-ниска валидационна грешка и начертайте двете криви с вертикална линия при избраната степен.
Мини-тест за проверка
Отговори си наум (или на глас!) и чак тогава разкрий отговора.
1. Защо методът се нарича „най-малки квадрати“, а не просто „най-малки грешки“?
2. Полином от степен 12 има RMSE 0.1 върху обучаващите данни и 2.5 върху валидационните. Какво се случва и какво бихте направили?
3. Какво означава R² = 0.85 и може ли R² да бъде отрицателен?
4. Защо PolynomialFeatures и LinearRegression се обединяват в Pipeline, вместо да се викат поотделно?
Речник на термините
Виж пълния речник на курсаy - y_pred между истинската и прогнозираната стойност за една точка; метриките MAE, MSE и RMSE се изчисляват от остатъците.y, който моделът обяснява: 1 е идеално, 0 е колкото прогноза „средната стойност“, а отрицателен е по-лошо от нея.x, x², ..., x^d; кривата е нелинейна по x, но моделът остава линеен по параметрите и се решава с най-малките квадрати.sklearn.preprocessing, който от входните признаци създава всички степени и произведения до зададена степен degree; в конвейер се прилага автоматично и при fit, и при predict.Провери знанията
Бърз тест с избор от отговори върху термините на модула — с точки и моментална обратна връзка.
Провери знанията си
9 въпроса върху термините от модула. Показваме определение — ти избираш правилния термин.
Материали от часовете
Задачи и тестове, давани в клас по тази тема.
Препоръки за този модул
- Преди да обучавате каквото и да е, начертайте точките с
plt.scatter– формата на облака подсказва дали права е достатъчна или трябва полином, и показва отклоняващи се стойности, които ще изкривят най-малките квадрати. - Проверете поне веднъж формулите на ръка: сметнете наклона с numpy по формулата със средните и го сравнете с
model.coef_– когато двете съвпаднат, „черната кутия“LinearRegressionпрестава да бъде магия. - Фиксирайте
random_stateвtrain_test_splitи зърното наnp.random.default_rng, за да получавате едни и същи числа при всяко пускане; после сменете стойността и вижте колко се променя валидационната грешка – това е дисперсията на живо. - Работете с актуален scikit-learn (1.4 или по-нов):
root_mean_squared_errorсъществува от версия 1.4, а старият параметърsquared=Falseнаmean_squared_errorе премахнат в 1.6. Версията се вижда сimport sklearn; print(sklearn.__version__).