Melatih LinearRegression dengan scikit-learn
Pelajar akan menggunakan sklearn.linear_model.LinearRegression untuk memadankan model pada data latihan, membuat ramalan, dan memeriksa pekali yang dipelajari.
Melatih LinearRegression dengan scikit-learn ialah pelajaran Machine Learning Academy percuma di CoddyKit. Ini ialah pelajaran 3 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Machine Learning Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Machine Learning Academy merangkumi sejumlah 4 pelajaran.
API LinearRegression scikit-learn
Kelas LinearRegression Scikit-learn menyediakan API yang kemas dan konsisten untuk memadankan regresi linear kuasa dua terkecil biasa. Seperti semua penganggar Scikit-learn, ia mengikut corak yang sama: wujudkan tika, padankan, ramalkan.
Di sebalik tabir, ia menggunakan Persamaan Normal (atau penguraian SVD yang stabil secara berangka untuk matriks ciri yang besar) bagi mencari pemberat optimum yang tepat dalam satu pengiraan — tiada gelung latihan berlelar diperlukan. Ini menjadikannya sangat pantas walaupun pada set data besar dengan banyak ciri.
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 parametersMenyediakan Data
Sebelum latihan, data anda mestilah dalam bentuk yang betul. scikit-learn menjangkakan:
- X — tatasusunan 2D berbentuk
(n_samples, n_features) - y — tatasusunan 1D berbentuk
(n_samples,)
Ralat bentuk yang paling biasa ialah menghantar tatasusunan 1D untuk X apabila anda mempunyai satu ciri. Penyelesaiannya ialah mengubah bentuk dengan .reshape(-1, 1). Sentiasa bahagikan data kepada set latihan dan ujian sebelum sebarang pemadanan — penilaian pada data latihan memberikan skor yang kelihatan sempurna secara mengelirukan.
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)Memadankan Model
Memanggil model.fit(X_train, y_train) mengira pemberat optimum menggunakan Persamaan Normal dan menyimpannya dalam objek model. Selepas pemadanan, dua atribut tersedia:
model.coef_— tatasusunan pemberat, satu untuk setiap cirimodel.intercept_— terma pintasan (skalar)
Garis bawah di hujung nama atribut ialah konvensyen scikit-learn yang menunjukkan bahawa atribut itu ditetapkan semasa pemadanan — atribut tersebut belum wujud sebelum fit() dipanggil.
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 ~50000Membuat Ramalan
Selepas pemadanan, panggil model.predict(X) untuk menghasilkan ramalan. Ini mengira hasil darab titik matriks ciri dengan pemberat yang dipelajari, kemudian menambah pintasan. Anda boleh membuat ramalan pada data latihan, data ujian atau data baharu sepenuhnya.
Ingat: penilaian pada data latihan bukan anggaran prestasi yang sah. Sentiasa nilaikan pada set ujian yang diketepikan untuk mendapatkan anggaran jujur tentang prestasi model pada data yang belum pernah dilihat.
# 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}')Menilai pada Set Ujian
Gunakan fungsi metrik scikit-learn untuk mengukur prestasi pada set ujian. Pintasan model.score(X_test, y_test) mengembalikan R² secara terus. Untuk gambaran yang lengkap, kira juga RMSE dan MAE.
Membandingkan metrik ini merentas model yang berbeza (contohnya, regresi linear berbanding hutan rawak) membolehkan anda memilih pendekatan terbaik untuk set data anda secara objektif. Sentiasa sertakan garis dasar naif (seperti sentiasa meramalkan nilai mean bagi y) untuk mengesahkan bahawa model anda benar-benar memberikan nilai tambahan.
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!)')Memvisualkan Garis Regresi
Selepas pemadanan, plotkan garis regresi yang dipelajari di atas plot serakan data latihan. Pemeriksaan visual ini menjawab soalan berikut: adakah garis itu munasabah? Adakah kedudukannya lebih kurang betul? Adakah terdapat kumpulan besar pencilan yang sentiasa terlepas daripada model?
Untuk model dengan satu ciri, perkara ini mudah dilakukan. Untuk model dengan berbilang ciri, anda perlu memplotkan ramalan berbanding nilai sebenar (plot baki atau plot serakan “ramalan berbanding sebenar”), kerana sempadan keputusan berada dalam ruang berdimensi tinggi.
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()Mentafsir Pekali
Nilai coef_ yang dipelajari mempunyai tafsiran perniagaan secara langsung. Bagi model harga rumah dengan berbilang ciri, setiap pekali memberitahu anda sejauh mana harga yang diramalkan berubah apabila ciri tersebut meningkat sebanyak satu unit, sementara semua ciri lain dikekalkan tetap (tafsiran ceteris paribus).
Walau bagaimanapun, tafsiran ini hanya sah apabila ciri berada pada skala yang serupa. Jika satu ciri diukur dalam meter dan satu lagi dalam kilometer, pekalinya tidak boleh dibandingkan secara langsung. Sentiasa skalakan ciri sebelum mentafsir pekali dalam model dengan berbilang ciri.
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}')Analisis Baki
Memplotkan baki berbanding nilai yang diramalkan ialah langkah diagnostik yang penting. Bagi model yang dipadankan dengan baik, baki sepatutnya terserak secara rawak di sekitar sifar tanpa corak yang dapat dikenal pasti. Corak sistematik menunjukkan masalah:
- Bentuk corong (baki tersebar lebih luas bagi ramalan yang lebih besar) menunjukkan heteroskedastisiti — varians ralat tidak malar.
- Corak melengkung menunjukkan hubungan sebenar adalah tak linear dan model linear kurang padan.
- Baki yang secara sistematik positif atau negatif bagi julat ramalan tertentu bermaksud model berat sebelah dalam julat tersebut.
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}')Regresi Linear Teregular
LinearRegression biasa boleh terlebih padan apabila anda mempunyai banyak ciri berbanding contoh latihan, atau apabila ciri sangat berkorelasi (multikolineariti). Scikit-learn menyediakan dua varian teregular:
- Ridge (regularisasi L2) — mengecilkan semua pekali ke arah sifar secara berkadar, mengekalkan semua ciri tetapi mengurangkan magnitudnya.
- Lasso (regularisasi L1) — mengecilkan sesetengah pekali hingga menjadi sifar sepenuhnya, sekali gus melaksanakan pemilihan ciri.
Parameter alpha mengawal kekuatan regularisasi: alpha lebih tinggi = pengecilan lebih besar = model lebih ringkas.
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}')Skor Pengesahan Silang
Satu pembahagian latihan-ujian boleh memberikan anggaran prestasi model yang mengelirukan, sama ada terlalu tinggi atau terlalu rendah, bergantung pada contoh yang kebetulan masuk ke dalam set ujian. Pengesahan silang memberikan anggaran yang lebih boleh dipercayai dengan mempuratakan prestasi merentas beberapa lipatan.
Gunakan cross_val_score untuk penilaian k-lipatan pantas tanpa membahagikan data secara manual. Skor yang dikembalikan adalah satu untuk setiap lipatan; laporkan mean dan sisihan piawai untuk menunjukkan prestasi yang dijangka serta kebolehubahannya.
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})')Saluran Paip Menyeluruh
Dalam aliran kerja ML profesional, prapemprosesan dan model sentiasa digabungkan ke dalam Pipeline. Ini menghalang kebocoran data semasa pengesahan silang (penskalakan dipadankan pada setiap lipatan latihan secara berasingan) dan memudahkan penggunaan (satu objek untuk disimpan dan dimuatkan).
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.')Semakan Pantas
Uji pemahaman anda tentang konsep Pembelajaran Mesin dengan Python daripada pelajaran ini.
Ringkasan Pelajaran
Dalam pelajaran ini, anda belajar bahawa: fit() mengira pemberat optimum yang disimpan dalam coef_ dan intercept_, predict() menggunakan garis yang dipelajari pada data baharu, dan plot baki mendedahkan sama ada andaian linear dipenuhi atau model yang lebih kompleks diperlukan. Seterusnya, kita akan mengembangkan regresi linear kepada berbilang ciri, mempelajari cara mentafsir setiap pekali sebagai ukuran kepentingan ciri, dan membuat penilaian menggunakan R-kuasa dua.
Pelajari Python dengan tutor kecerdasan buatan — percuma
Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.
- Kursus
- 30
- Pelajaran
- 120
Soalan Lazim
Adakah pelajaran “Melatih LinearRegression dengan scikit-learn” percuma?
Ya — teks penuh “Melatih LinearRegression dengan scikit-learn” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Machine Learning Academy, tingkat taraf kepada CoddyKit PRO. Kursus Machine Learning Academy merangkumi sejumlah 4 pelajaran.
Apakah yang akan saya pelajari dalam “Melatih LinearRegression dengan scikit-learn”?
Pelajar akan menggunakan sklearn.linear_model.LinearRegression untuk memadankan model pada data latihan, membuat ramalan, dan memeriksa pekali yang dipelajari. Anda berlatih Machine Learning Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.
Adakah saya memerlukan pengalaman untuk memulakan Machine Learning Academy?
Tiada pengalaman terdahulu diperlukan. Pembelajaran Machine Learning Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 3 daripada 4.
Berapa lamakah pelajaran “Melatih LinearRegression dengan scikit-learn” diambil?
Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.
Bolehkah saya menulis dan menjalankan kod dalam pelajaran Machine Learning Academy ini?
Ya. Setiap pelajaran Machine Learning Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.
Semua pelajaran dalam kursus ini
- Persamaan Garis: Kecerunan, Pintasan dan Ramalan
- Fungsi Kos dan Kuasa Dua Terkecil
- Melatih LinearRegression dengan scikit-learn
- Regresi Linear Berganda dan Kepentingan Ciri