🍧 1. Apa Itu Linear Regression?

Definisi Sederhana

Linear Regression adalah cara komputer menggambar garis lurus terbaik yang melewati sekumpulan titik-titik data, supaya kita bisa memprediksi sesuatu.

Setiap tanda ✕ adalah data harian Pak Budi. Garis putus-putus (· · ·) adalah “garis terbaik” yang ditarik komputer. Dengan garis ini, kalau kita tahu suhu besok, kita tinggal lihat garisnya dan dapat prediksi jumlah es!

Kenapa Disebut “Linear”?

Kata “Linear” artinya “garis lurus”. Jadi Linear Regression artinya: mencari prediksi yang membentuk garis lurus. Bukan garis melengkung, bukan zigzag, tapi garis lurus yang paling pas melewati titik-titik data kita.

🌍 2. Kenapa Harus Belajar Ini?

Linear Regression bukan cuma teori di buku. Ini dipakai setiap hari di dunia nyata oleh perusahaan besar maupun toko kecil!

Kenapa Linear Regression Penting dalam Machine Learning?

📏 3. Konsep Dasar: Garis Lurus y = mx + b

Rumus Garis Lurus

Apa Itu Slope (Kemiringan)?

Apa Itu Intercept (Titik Potong)?

Intercept (b) adalah nilai awal — nilai y ketika x = 0.

Multiple Linear Regression (Banyak Input)

Di dunia nyata, prediksi biasanya tergantung pada banyak hal, bukan cuma satu.

🎯 4. Bagaimana Komputer Belajar? (Cost Function)

Oke, sekarang pertanyaan besarnya: dari sekian banyak garis lurus yang bisa digambar, bagaimana komputer tahu mana garis yang paling bagus?

Error (Kesalahan) = Prediksi − Kenyataan

Untuk setiap data, kita hitung selisih antara apa yang diprediksi model dan apa yang sebenarnya terjadi:

Mean Squared Error (MSE) — Cara Menghitung Total Kesalahan

Kenapa tidak cukup hanya menjumlahkan error saja? Karena error bisa positif dan negatif — kalau dijumlahkan langsung, bisa saling menghapus!

Contoh Hitung MSE Langkah Demi Langkah

Pak Budi punya 4 data penjualan es. Model kita memprediksi:

🧮 5. Normal Equation: Cara Instan

Kapan Pakai Normal Equation?

Implementasi Python

# Normal Equation dari nol
import numpy as np

# Data Pak Budi: suhu → es terjual
X = np.array([28, 30, 33, 35]).reshape(-1, 1)  # input (kolom)
y = np.array([20, 30, 40, 50])                  # target

# Tambah kolom 1 di depan (untuk intercept/bias)
X_b = np.column_stack([np.ones(len(X)), X])

# Rumus Normal Equation: w = (XᵀX)⁻¹ Xᵀy
w = np.linalg.inv(X_b.T @ X_b) @ X_b.T @ y

print(f"Intercept (b) = {w[0]:.2f}")
print(f"Slope (m)     = {w[1]:.2f}")
print(f"Prediksi suhu 33°: {w[0] + w[1]*33:.1f} gelas es")

🏔️ 6. Gradient Descent: Turun Gunung Cari Lembah

Rumus Update Gradient Descent

Learning Rate: Jangan Terlalu Besar, Jangan Terlalu Kecil!

Implementasi Python

# Gradient Descent dari nol
import numpy as np

# Data
X = np.array([28, 30, 33, 35], dtype=float)
y = np.array([20, 30, 40, 50], dtype=float)

# Inisialisasi acak
w = 0.0  # slope
b = 0.0  # intercept
alpha = 0.0001  # learning rate
n = len(X)

# Training loop
for epoch in range(1, 10001):
    # 1. Hitung prediksi
    y_pred = w * X + b

    # 2. Hitung gradient (turunan MSE terhadap w dan b)
    dw = (-2/n) * np.sum(X * (y - y_pred))  # arah koreksi w
    db = (-2/n) * np.sum(y - y_pred)         # arah koreksi b

    # 3. Update w dan b
    w = w - alpha * dw
    b = b - alpha * db

    if epoch % 2000 == 0:
        mse = np.mean((y - y_pred)**2)
        print(f"Epoch {epoch}: w={w:.4f}, b={b:.4f}, MSE={mse:.4f}")

print(f"\nHasil akhir: y = {w:.2f}x + {b:.2f}")
print(f"Prediksi suhu 33°: {w*33 + b:.1f} gelas es")

Normal Equation vs Gradient Descent

🐍 7. Praktek Python: Dari Nol Sampai Prediksi

Sekarang kita gabungkan semuanya dalam satu contoh lengkap — dari data mentah sampai prediksi jadi!

Contoh Lengkap: Prediksi Harga Rumah Sederhana

# ============================
# LANGKAH 1: Siapkan Bahan (Data)
# ============================
import numpy as np

# Data: [luas_m2, jumlah_kamar]
X = np.array([
    [36, 2],   # rumah kecil
    [50, 2],
    [60, 3],
    [72, 3],
    [80, 4],
    [100, 4],
    [120, 5],
])
# Harga dalam juta rupiah
y = np.array([250, 350, 420, 500, 580, 700, 850])

print("Data siap! Jumlah rumah:", len(y))
print("Fitur: luas (m²) dan jumlah kamar")

# ============================
# LANGKAH 2: Olah Bahan (Normalisasi)
# ============================
# Supaya gradient descent bekerja lebih baik,
# kita buat semua angka jadi skala yang mirip (0-1)
X_mean = X.mean(axis=0)
X_std = X.std(axis=0)
X_norm = (X - X_mean) / X_std

y_mean = y.mean()
y_std = y.std()
y_norm = (y - y_mean) / y_std

print(f"Rata-rata luas: {X_mean[0]:.0f} m²")
print(f"Rata-rata harga: {y_mean:.0f} juta")

# ============================
# LANGKAH 3: Masak (Training dengan Gradient Descent)
# ============================
n_samples, n_features = X_norm.shape
w = np.zeros(n_features)  # [w_luas, w_kamar]
b = 0.0
alpha = 0.01
epochs = 1000

for epoch in range(epochs):
    y_pred = X_norm @ w + b
    error = y_pred - y_norm

    dw = (2/n_samples) * (X_norm.T @ error)
    db = (2/n_samples) * np.sum(error)

    w -= alpha * dw
    b -= alpha * db

    if (epoch+1) % 200 == 0:
        mse = np.mean(error**2)
        print(f"Epoch {epoch+1}: MSE = {mse:.6f}")

print(f"\nWeight: luas={w[0]:.4f}, kamar={w[1]:.4f}")
print(f"Bias: {b:.4f}")

# ============================
# LANGKAH 4: Cicipi (Evaluasi)
# ============================
y_pred_final = X_norm @ w + b
# Kembalikan ke skala asli
y_pred_asli = y_pred_final * y_std + y_mean

print("\n--- Perbandingan ---")
for i in range(len(y)):
    print(f"Rumah {i+1}: Asli={y[i]} juta, Prediksi={y_pred_asli[i]:.0f} juta")

# ============================
# LANGKAH 5: Sajikan (Prediksi Rumah Baru)
# ============================
rumah_baru = np.array([75, 3])  # 75m², 3 kamar
rumah_norm = (rumah_baru - X_mean) / X_std
harga_pred = (rumah_norm @ w + b) * y_std + y_mean
print(f"\n🏠 Rumah baru (75m², 3 kamar)")
print(f"   Prediksi harga: {harga_pred:.0f} juta rupiah")

Cara Gampang Pakai scikit-learn

Di dunia kerja, kita biasanya pakai library scikit-learn supaya lebih mudah:

from sklearn.linear_model import LinearRegression
import numpy as np

X = np.array([[36,2],[50,2],[60,3],[72,3],[80,4],[100,4],[120,5]])
y = np.array([250, 350, 420, 500, 580, 700, 850])

# Buat & latih model (cuma 2 baris!)
model = LinearRegression()
model.fit(X, y)

# Lihat hasilnya
print(f"Bobot: luas={model.coef_[0]:.2f}, kamar={model.coef_[1]:.2f}")
print(f"Bias: {model.intercept_:.2f}")

# Prediksi rumah baru
harga = model.predict([[75, 3]])
print(f"Rumah 75m² 3 kamar → {harga[0]:.0f} juta")

🛡️ 8. Regularisasi: Jangan Terlalu Hafal!

Overfitting vs Underfitting

Ridge Regression (L2 Regularization)

Lasso Regression (L1 Regularization)

Perbandingan Ridge vs Lasso

Implementasi Python

from sklearn.linear_model import Ridge, Lasso
import numpy as np

X = np.array([[36,2],[50,2],[60,3],[72,3],[80,4],[100,4],[120,5]])
y = np.array([250, 350, 420, 500, 580, 700, 850])

# Ridge (L2)
ridge = Ridge(alpha=1.0)  # alpha = λ (lambda)
ridge.fit(X, y)
print("Ridge weights:", ridge.coef_)

# Lasso (L1)
lasso = Lasso(alpha=1.0)
lasso.fit(X, y)
print("Lasso weights:", lasso.coef_)
# Perhatikan: beberapa weight mungkin jadi 0!

📊 9. Evaluasi Model: Seberapa Bagus?

Setelah model dilatih, kita perlu tahu: “Seberapa bagus sih model ini?”

1. MSE (Mean Squared Error)

Sudah kita bahas — rata-rata kuadrat error. Makin kecil = makin bagus. Satuan: kuadrat dari target (misal: juta² kalau target dalam juta).

2. RMSE (Root Mean Squared Error)

3. MAE (Mean Absolute Error)

4. R² Score (Coefficient of Determination)

Implementasi Python

from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
import numpy as np

y_asli    = np.array([250, 350, 420, 500, 580, 700, 850])
y_prediksi = np.array([260, 340, 430, 490, 590, 680, 860])

mse  = mean_squared_error(y_asli, y_prediksi)
rmse = np.sqrt(mse)
mae  = mean_absolute_error(y_asli, y_prediksi)
r2   = r2_score(y_asli, y_prediksi)

print(f"MSE  = {mse:.2f}")
print(f"RMSE = {rmse:.2f} juta (rata-rata meleset)")
print(f"MAE  = {mae:.2f} juta")
print(f"R²   = {r2:.4f} ({r2*100:.1f}% pola terjelaskan)")

⚖️ 10. Bias vs Variance

Cara Mengatasi

🏁 11. Rangkuman & Tips