Модул 139

Линейна и полиномна регресия – най-малки квадрати и преобучение

Регресията предсказва число – цена, точки на тест, спирачен път – по едно или повече измервания. Как методът на най-малките квадрати намира най-добрата права, как `LinearRegression` и `PolynomialFeatures` правят това с няколко реда код, какво казват метриките MAE, RMSE и R² и защо полином от висока степен изглежда идеален върху обучаващите данни, а се проваля на нови.

Теория

Регресия (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Какво измерваКак се чете
MAEmean_absolute_error(y, y_pred)Средна абсолютна грешка, в единиците на y„Средно бъркаме с толкова“; по-малко е по-добре
MSEmean_squared_error(y, y_pred)Среден квадрат на грешката, в квадратни единициВеличината, която най-малките квадрати минимизират; трудна за четене директно
RMSEroot_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)

Код за анализ и пренаписване

Най-малки квадрати по три начина и метрики

script.py
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: кой се преобучава?

script.py
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, вместо да се викат поотделно?

Речник на термините

Виж пълния речник на курса
Регресия (regression)
Задача на машинното обучение, в която моделът предсказва числова стойност (цена, температура, точки) по един или повече признаци.
Метод на най-малките квадрати (least squares)
Начин за намиране на параметрите на модела, при който сумата на квадратите на остатъците е минимална; за линейния модел има точно решение по формули или през нормалното уравнение.
Остатък (residual)
Разликата y - y_pred между истинската и прогнозираната стойност за една точка; метриките MAE, MSE и RMSE се изчисляват от остатъците.
Коефициент на детерминация (R²)
Дял от разсейването на y, който моделът обяснява: 1 е идеално, 0 е колкото прогноза „средната стойност“, а отрицателен е по-лошо от нея.
Полиномна регресия (polynomial regression)
Линейна регресия върху разширени признаци x, x², ..., x^d; кривата е нелинейна по x, но моделът остава линеен по параметрите и се решава с най-малките квадрати.
PolynomialFeatures
Трансформатор от sklearn.preprocessing, който от входните признаци създава всички степени и произведения до зададена степен degree; в конвейер се прилага автоматично и при fit, и при predict.
Преобучение (overfitting)
Състояние, при което моделът следва шума в обучаващите данни: грешката на обучение е много ниска, а грешката върху нови данни – висока.
Компромис отклонение–дисперсия (bias–variance tradeoff)
Твърде простият модел има голямо отклонение (не улавя формата – недообучение), твърде сложният – голяма дисперсия (следва шума – преобучение); целта е балансът между двете.
Крива на валидация (validation curve)
Графика на грешката на обучение и на валидация спрямо сложността на модела (например степента на полинома); степента се избира в минимума на валидационната крива.

Провери знанията

Бърз тест с избор от отговори върху термините на модула — с точки и моментална обратна връзка.

Провери знанията си

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__).

Учебен наръчник — теория, примери, задачи и тестове по предметите от учебния план.

Натисни Ctrl K или / отвсякъде, за да търсиш.