Lineaarisen regression opettaminen scikit-learnilla
Sovita malli harjoitusdataan sklearn.linear_model.LinearRegression-luokalla, tee ennusteita ja tarkastele opittuja kertoimia.
Lineaarisen regression opettaminen scikit-learnilla on ilmainen Machine Learning Academy-oppitunti CoddyKitissä. Tämä on oppitunti 3/4. Voit lukea koko oppitunnin alta ilmaiseksi ja harjoitella sen jälkeen käytännössä selaimessa sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla. Oppitunti kuuluu Machine Learning Academy-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Machine Learning Academy-kurssilla on yhteensä 4 oppituntia.
scikit-learnin LinearRegression-rajapinta
Scikit-learnin LinearRegression-luokka tarjoaa selkeän ja yhdenmukaisen rajapinnan tavallisen pienimmän neliösumman lineaarisen regression sovittamiseen. Kuten kaikki scikit-learnin estimaattorit, se noudattaa samaa kaavaa: luo olio, sovita malli ja tee ennusteita.
Konepellin alla se käyttää normaal yhtälöä (tai numeerisesti vakaata singulaariarvohajotelmaa suurille piirrematriiseille) löytääkseen optimaaliset painot yhdellä laskutoimituksella — iteratiivista koulutussilmukkaa ei tarvita. Tämän ansiosta se on erittäin nopea jopa suurilla aineistoilla, joissa on paljon piirteitä.
from sklearn.linear_model import LinearRegression
import numpy as np
# Instantiate with optional parameters
model = LinearRegression(
fit_intercept=True, # default: add bias term
copy_X=True, # don't modify input arrays
n_jobs=-1 # use all CPU cores
)
print(model) # shows default parametersDatan valmistelu
Ennen koulutusta datan on oltava oikean muotoista. scikit-learn odottaa seuraavaa:
- X — kaksiulotteinen taulukko, jonka muoto on
(n_samples, n_features) - y — yksiulotteinen taulukko, jonka muoto on
(n_samples,)
Yleisin muotovirhe on antaa X:lle yksiulotteinen taulukko silloin, kun piirteitä on yksi. Korjaa tämä muuttamalla muotoa komennolla .reshape(-1, 1). Jaa data aina koulutus- ja testijoukkoihin ennen sovittamista — koulutusdatalla tehty arviointi antaa harhaanjohtavan täydellisiä tuloksia.
import numpy as np
from sklearn.model_selection import train_test_split
# Simulate housing data
np.random.seed(42)
sqft = np.random.uniform(500, 3000, 200)
price = 150 * sqft + 50000 + np.random.normal(0, 25000, 200)
# Reshape X to 2D (n_samples, n_features)
X = sqft.reshape(-1, 1) # shape (200, 1)
y = price # shape (200,)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, random_state=42
)
print('Train size:', X_train.shape, '| Test size:', X_test.shape)Mallin sovittaminen
Kutsumalla model.fit(X_train, y_train) lasketaan optimaaliset painot normaalin yhtälön avulla ja tallennetaan ne malliolioon. Sovittamisen jälkeen käytettävissä on kaksi attribuuttia:
model.coef_— painojen taulukko, yksi paino kutakin piirrettä kohtimodel.intercept_— vakiotermi (skalaariluku)
Attribuuttien nimien lopussa oleva alaviiva on scikit-learnin käytäntö, joka ilmaisee attribuutin asetetun sovittamisen aikana — sitä ei ole olemassa ennen kuin fit() on kutsuttu.
from sklearn.linear_model import LinearRegression
import numpy as np
from sklearn.model_selection import train_test_split
np.random.seed(42)
X = np.random.uniform(500, 3000, 200).reshape(-1, 1)
y = 150 * X.ravel() + 50000 + np.random.normal(0, 25000, 200)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
model = LinearRegression()
model.fit(X_train, y_train)
print(f'Slope (coef_): {model.coef_[0]:.2f}') # should be ~150
print(f'Intercept: {model.intercept_:.2f}') # should be ~50000Ennusteiden tekeminen
Kun malli on sovitettu, tee ennusteita kutsumalla model.predict(X). Tämä laskee piirrematriisin ja opittujen painojen pistetulon ja lisää siihen vakiotermin. Voit tehdä ennusteita koulutusdatasta, testidatasta tai kokonaan uudesta datasta.
Muista, että koulutusdatalla tehty arviointi ei ole kelvollinen suorituskyvyn mittari. Arvioi malli aina erillisellä testijoukolla, jotta saat rehellisen arvion siitä, miten hyvin se toimii näkemättömällä datalla.
# Predict on test set
y_pred = model.predict(X_test)
print('First 5 predictions vs actual:')
for actual, pred in zip(y_test[:5], y_pred[:5]):
print(f' Actual: ${actual:,.0f} | Predicted: ${pred:,.0f} | Error: ${actual-pred:,.0f}')
# Predict a single new house
new_house = np.array([[1750]]) # must be 2D
print(f'\nPrediction for 1750 sqft: ${model.predict(new_house)[0]:,.0f}')Arviointi testijoukolla
Käytä scikit-learnin metriikkafunktioita testijoukon suorituskyvyn mittaamiseen. Lyhyt komento model.score(X_test, y_test) palauttaa R²-arvon suoraan. Muodosta kokonaiskuvan saamiseksi myös RMSE- ja MAE-arvot.
Vertaamalla näitä metriikoita eri mallien (esimerkiksi lineaarisen regression ja satunnaismetsän) välillä voit valita aineistollesi parhaiten sopivan lähestymistavan objektiivisesti. Sisällytä aina naiivi vertailutaso, kuten y:n keskiarvon ennustaminen joka kerta, jotta voit varmistaa mallin todella tuovan lisäarvoa.
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
import numpy as np
y_pred = model.predict(X_test)
rmse = np.sqrt(mean_squared_error(y_test, y_pred))
mae = mean_absolute_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)
print(f'Test RMSE: ${rmse:,.0f}')
print(f'Test MAE: ${mae:,.0f}')
print(f'Test R2: {r2:.3f}')
# Baseline: always predict the mean
baseline_rmse = np.sqrt(((y_test - y_train.mean()) ** 2).mean())
print(f'Baseline RMSE: ${baseline_rmse:,.0f} (must beat this!)')Regressiosuoran visualisointi
Kun malli on sovitettu, piirrä opittu regressiosuora koulutusdatan hajontakuvion päälle. Tämä visuaalinen tarkistus auttaa vastaamaan kysymyksiin: onko suora järkevä? Onko se suunnilleen oikeassa paikassa? Jättääkö malli jatkuvasti huomiotta suuria poikkeavien havaintojen ryhmiä?
Yhden piirteen mallissa tämä on suoraviivaista. Usean piirteen malleissa sinun on sen sijaan piirrettävä ennusteet suhteessa todellisiin arvoihin (jäännöskuvaaja tai ennusteiden ja todellisten arvojen hajontakuvio), koska päätösraja sijaitsee moniulotteisessa avaruudessa.
import matplotlib.pyplot as plt
import numpy as np
# Plot training data and the fitted line
plt.figure(figsize=(8, 5))
plt.scatter(X_train, y_train, alpha=0.4, label='Training data')
plt.scatter(X_test, y_test, alpha=0.4, color='orange', label='Test data')
# Draw the regression line across the full range
x_range = np.linspace(500, 3000, 100).reshape(-1, 1)
y_range = model.predict(x_range)
plt.plot(x_range, y_range, 'r-', linewidth=2, label='Regression line')
plt.xlabel('Square Footage')
plt.ylabel('Price ($)')
plt.legend()
plt.title('Linear Regression Fit')
plt.show()Kertoimien tulkitseminen
Opituilla coef_-arvoilla on suora liiketoiminnallinen tulkinta. Useita piirteitä käyttävässä asuntojen hintamallissa kukin kerroin kertoo, kuinka paljon ennustettu hinta muuttuu, kun kyseinen piirre kasvaa yhdellä yksiköllä ja kaikki muut piirteet pidetään vakioina (ceteris paribus -tulkinta).
Tämä tulkinta on kuitenkin pätevä vain, kun piirteet ovat samankaltaisilla asteikoilla. Jos yksi piirre ilmoitetaan metreinä ja toinen kilometreinä, niiden kertoimia ei voi verrata suoraan. Standarisoi piirteet aina ennen kertoimien tulkitsemista usean piirteen malleissa.
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler
import numpy as np
import pandas as pd
# Multi-feature housing data
features = ['sqft', 'bedrooms', 'bathrooms', 'age']
np.random.seed(0)
X_data = pd.DataFrame({
'sqft': np.random.randint(600, 3000, 100),
'bedrooms': np.random.randint(1, 6, 100),
'bathrooms': np.random.randint(1, 4, 100),
'age': np.random.randint(1, 50, 100)
})
y_data = 150*X_data['sqft'] + 8000*X_data['bedrooms'] - 500*X_data['age'] + 30000
model = LinearRegression().fit(X_data, y_data)
for feat, coef in zip(features, model.coef_):
print(f'{feat}: {coef:.1f}')Jäännösten analysointi
Jäännösten piirtäminen ennustettuja arvoja vastaan on tärkeä diagnostiikkavaihe. Hyvin sovitetun mallin jäännösten pitäisi olla satunnaisesti hajallaan nollan ympärillä ilman havaittavaa kuviota. Järjestelmälliset kuviot kertovat ongelmasta:
- Suppilomainen muoto (jäännösten hajonta kasvaa ennusteiden suurentuessa) kertoo heteroskedastisuudesta — virheiden varianssi ei ole vakio.
- Kaareva kuvio kertoo, että todellinen yhteys on epälineaarinen ja lineaarinen malli alisovittuu.
- Jos jäännökset ovat tietyillä ennustealueilla järjestelmällisesti positiivisia tai negatiivisia, malli on kyseisellä alueella harhainen.
import matplotlib.pyplot as plt
import numpy as np
y_pred = model.predict(X_test)
residuals = y_test - y_pred
plt.figure(figsize=(8, 5))
plt.scatter(y_pred, residuals, alpha=0.5)
plt.axhline(y=0, color='red', linestyle='--', linewidth=1.5)
plt.xlabel('Predicted Values')
plt.ylabel('Residuals')
plt.title('Residual Plot (should be random scatter around 0)')
plt.show()
print(f'Mean residual: {residuals.mean():.2f} (should be ~0)')
print(f'Std of residuals: {residuals.std():.2f}')Regularisoitu lineaarinen regressio
Pelkkä LinearRegression voi ylisovittua, kun piirteitä on paljon suhteessa koulutusesimerkkeihin tai kun piirteet korreloivat voimakkaasti keskenään (multikollineaarisuus). Scikit-learn tarjoaa kaksi regularisoitua muunnelmaa:
- Ridge (L2-regularisointi) — pienentää kaikkia kertoimia suhteellisesti kohti nollaa, jolloin kaikki piirteet säilyvät mutta niiden suuruus pienenee.
- Lasso (L1-regularisointi) — pienentää joidenkin kertoimien arvon kokonaan nollaan ja tekee siten käytännössä piirteiden valintaa.
alpha-parametri määrittää regularisoinnin voimakkuuden: suurempi alpha = voimakkaampi pienennys = yksinkertaisempi malli.
from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score
import numpy as np
np.random.seed(42)
X = np.random.randn(100, 20) # 20 features, many irrelevant
y = 3*X[:, 0] + 2*X[:, 1] + np.random.randn(100)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)
for name, model in [('OLS', LinearRegression()),
('Ridge', Ridge(alpha=1.0)),
('Lasso', Lasso(alpha=0.1))]:
model.fit(X_train, y_train)
print(f'{name} R2: {r2_score(y_test, model.predict(X_test)):.3f}')Ristiinvalidoinnin pisteet
Yksi jako koulutus- ja testijoukkoon voi antaa mallin suorituskyvystä harhaanjohtavan korkean tai matalan arvion sen mukaan, mitkä esimerkit sattuvat päätymään testijoukkoon. Ristiinvalidointi antaa luotettavamman arvion laskemalla suorituskyvyn keskiarvon useiden osajoukkojen yli.
Käytä cross_val_score-funktiota nopeaan k-osaiseen arviointiin ilman datan manuaalista jakamista. Palautetut pisteet ovat yksi kutakin osajoukkoa kohti; ilmoita keskiarvo ja keskihajonta, jotta sekä odotettu suorituskyky että sen vaihtelu käyvät ilmi.
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import cross_val_score
import numpy as np
np.random.seed(42)
X = np.random.randn(200, 3)
y = 2*X[:, 0] - X[:, 1] + np.random.randn(200)*0.5
model = LinearRegression()
scores = cross_val_score(
model, X, y,
cv=5, # 5-fold cross-validation
scoring='r2' # use R2 as the metric
)
print('CV R2 scores per fold:', scores.round(3))
print(f'Mean R2: {scores.mean():.3f} (+/- {scores.std():.3f})')Alusta loppuun ulottuva putki
Ammattimaisissa koneoppimisen työnkuluissa esikäsittely ja malli yhdistetään aina Pipeline-putkeksi. Tämä estää datavuodon ristiinvalidoinnin aikana (skaalain sovitetaan erikseen kunkin koulutusosajoukon perusteella) ja yksinkertaistaa käyttöönottoa (vain yksi olio tallennettavaksi ja ladattavaksi).
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import cross_val_score
import numpy as np
np.random.seed(42)
X = np.random.randn(200, 3)
y = 2*X[:, 0] - X[:, 1] + np.random.randn(200)*0.5
# Scale + Fit in one object
pipeline = Pipeline([
('scaler', StandardScaler()),
('model', LinearRegression())
])
scores = cross_val_score(pipeline, X, y, cv=5, scoring='r2')
print(f'Pipeline CV R2: {scores.mean():.3f} (+/- {scores.std():.3f})')
# Fit once for deployment
pipeline.fit(X, y)
print('Pipeline fitted and ready for deployment.')Pikatarkistus
Testaa tämän oppitunnin Pythonin koneoppimista koskevien käsitteiden ymmärtämistäsi.
Oppitunnin yhteenveto
Tässä oppitunnissa opit, että fit() laskee optimaaliset painot, jotka tallennetaan attribuutteihin coef_ ja intercept_, predict() soveltaa opittua suoraa uuteen dataan ja jäännöskuvaajat paljastavat, pitääkö lineaarinen oletus paikkansa vai tarvitaanko monimutkaisempaa mallia. Seuraavaksi laajennamme lineaarisen regression useisiin piirteisiin, opimme tulkitsemaan kutakin kerrointa piirteen merkityksen mittana ja arvioimme mallia R-neliön avulla.
Opi Python tekoälytuutorin avulla — ilmaiseksi
Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.
- Kurssit
- 30
- Oppitunnit
- 120
Usein kysytyt kysymykset
Onko oppitunti ”Lineaarisen regression opettaminen scikit-learnilla” ilmainen?
Kyllä – oppitunnin ”Lineaarisen regression opettaminen scikit-learnilla” koko tekstin voi lukea täällä verkossa ilmaiseksi. Jos haluat harjoitella interaktiivisesti sisäänrakennetulla koodieditorilla ja ympäri vuorokauden käytettävissä olevan tekoälytuutorin avulla sekä avata koko Machine Learning Academy-kurssin, päivitä CoddyKit PROhon. Machine Learning Academy-kurssilla on yhteensä 4 oppituntia.
Mitä opin oppitunnilla ”Lineaarisen regression opettaminen scikit-learnilla”?
Sovita malli harjoitusdataan sklearn.linear_model.LinearRegression-luokalla, tee ennusteita ja tarkastele opittuja kertoimia. Harjoittelet Machine Learning Academy-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.
Tarvitsenko kokemusta aloittaakseni Machine Learning Academy-opiskelun?
Aiempi kokemus ei ole tarpeen. CoddyKitin Machine Learning Academy-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 3/4.
Kuinka kauan ”Lineaarisen regression opettaminen scikit-learnilla”-oppitunnin suorittaminen kestää?
Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.
Voinko kirjoittaa ja suorittaa koodia tällä Machine Learning Academy-oppitunnilla?
Kyllä. Jokainen Machine Learning Academy-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.
Kaikki tämän kurssin oppitunnit
- Suoran yhtälö: kulmakerroin, vakiotermi ja ennusteet
- Kustannusfunktiot ja pienimmän neliösumman menetelmä
- Lineaarisen regression opettaminen scikit-learnilla
- Moninkertainen lineaarinen regressio ja piirteiden tärkeys