📈 Linear Regression — Intuisi

Bayangkan kamu seorang data analyst di perusahaan properti. Bosmu bertanya: “Kalau rumah ukurannya 120m², kira-kira harganya berapa?”

Kamu punya data historis — luas rumah dan harganya. Linear regression membantu kamu menarik garis lurus terbaik melewati data itu, sehingga kamu bisa memprediksi harga rumah baru.

Kapan Digunakan di Dunia Kerja?

Visualisasi Interaktif

Geser slider untuk melihat bagaimana garis regresi berubah:

Titik biru = data, Garis merah = prediksi regresi. Coba ubah slope & intercept!

🔢 Linear Regression — Math Explained Simply

Jangan takut dengan matematikanya! Kita akan breakdown pelan-pelan.

Persamaan Garis

ŷ = prediksi, w = weight (slope/kemiringan), x = input (fitur), b = bias (intercept)

Cost Function — Mengukur Kesalahan

Bagaimana model tahu garisnya sudah bagus? Dengan Mean Squared Error (MSE):

Semakin kecil MSE, semakin bagus garis kita. Model berusaha meminimalkan nilai ini.

Gradient Descent — Cara Model Belajar

Bayangkan kamu berdiri di gunung berkabut dan ingin turun ke lembah terendah. Kamu tidak bisa melihat jauh, jadi kamu meraba ke arah paling curam ke bawah, selangkah demi selangkah. Itulah gradient descent!

α (learning rate) = seberapa besar langkah yang diambil. Terlalu besar → melewati lembah. Terlalu kecil → terlalu lama.

Simulasi Learning Rate

🐍 Implementasi Linear Regression di Python

Sekarang kita terapkan teori ke kode nyata yang bisa langsung kamu pakai di tempat kerja.

Cara 1: Scikit-Learn (Paling Umum di Industri)

import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split

# Data: luas rumah (m²) → harga (juta rupiah)
X = np.array([30,50,70,90,100,120,150]).reshape(-1,1)
y = np.array([200,350,480,600,700,850,1050])

# Split data
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# Train model
model = LinearRegression()
model.fit(X_train, y_train)

# Prediksi
print(f"Slope (w): {model.coef_[0]:.2f}")
print(f"Intercept (b): {model.intercept_:.2f}")
print(f"Prediksi 120m²: {model.predict([[120]])[0]:.0f} juta")

Cara 2: Dari Nol (Untuk Pemahaman Mendalam)

class SimpleLinearRegression:
    def __init__(self, lr=0.0001, epochs=1000):
        self.lr = lr
        self.epochs = epochs

    def fit(self, X, y):
        self.w = 0.0
        self.b = 0.0
        n = len(X)
        for _ in range(self.epochs):
            y_pred = self.w * X + self.b
            dw = (-2/n) * np.sum(X * (y - y_pred))
            db = (-2/n) * np.sum(y - y_pred)
            self.w -= self.lr * dw
            self.b -= self.lr * db

    def predict(self, X):
        return self.w * X + self.b

Interactive: Coba Prediksi

Masukkan luas rumah dan lihat prediksi harga (model: ŷ = 7.1x + 12):

📊 Model Evaluation: MSE, RMSE & R²

Setelah model dilatih, pertanyaan penting di dunia kerja: “Seberapa bagus model ini?” Ada 3 metrik utama yang wajib kamu kuasai.

1. Mean Squared Error (MSE)

Rata-rata dari kuadrat selisih antara nilai aktual dan prediksi. Semakin kecil = semakin baik. Kelemahannya: satuannya dikuadratkan, jadi sulit diinterpretasi langsung.

2. Root Mean Squared Error (RMSE)

Akar dari MSE — satuannya sama dengan target. Jika target dalam juta rupiah, RMSE juga dalam juta rupiah. Ini yang paling sering dilaporkan ke stakeholder.

3. R² (R-Squared / Coefficient of Determination)

Mengukur seberapa baik model menjelaskan variasi data. Nilainya 0–1 (bisa negatif jika model sangat buruk).

Implementasi di Python

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

y_actual = np.array([200, 350, 480, 700])
y_pred   = np.array([210, 340, 500, 680])

mse  = mean_squared_error(y_actual, y_pred)
rmse = np.sqrt(mse)
r2   = r2_score(y_actual, y_pred)

print(f"MSE:  {mse:.2f}")
print(f"RMSE: {rmse:.2f}")
print(f"R²:   {r2:.4f}")

Kalkulator Interaktif

Masukkan nilai aktual dan prediksi (pisahkan dengan koma):

⚖️ Bias-Variance Tradeoff

Di pekerjaan nyata, model jarang gagal karena “algoritmanya jelek”. Lebih sering gagal karena overfitting atau underfitting. Konsep inti untuk memahami ini adalah bias-variance tradeoff.

Underfitting (Bias Tinggi)

Model terlalu sederhana, tidak mampu menangkap pola data. Biasanya terjadi ketika fitur kurang relevan, model terlalu linear untuk data yang kompleks, atau regularisasi terlalu kuat.

Overfitting (Variance Tinggi)

Model “menghafal” data training, termasuk noise. Di produksi, performanya jatuh saat bertemu data baru.

Kenapa Ini Penting untuk Kebutuhan Kerja?

Stakeholder tidak peduli modelmu “bagus di training”. Mereka peduli hasil di dunia nyata. Jadi kamu harus bisa mengendalikan tradeoff ini lewat data, fitur, regularisasi, dan validasi.

Interaktif: Simulasi Kompleksitas Model

Anggap ini sebagai “tingkat kompleksitas”. Semakin tinggi, semakin mudah overfitting.

Cara Praktis Mengatasinya

🧩 Mini Project: Predicting Continuous Values

Mini project ini meniru alur kerja yang sering kamu temui di kantor: dari data mentah → model → evaluasi → rekomendasi perbaikan.

Dataset (Simulasi Dunia Kerja)

Kita pakai data sederhana: ad_spend (juta) → revenue (juta). Kamu bisa ganti nanti dengan datasetmu sendiri.

import pandas as pd

# contoh data
df = pd.DataFrame({
    "ad_spend": [5,10,15,20,25,30,35,40],
    "revenue":  [40,55,70,88,103,120,138,150]
})

Langkah Kerja (Checklist)

Template Kode End-to-End (Siap Dipakai)

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

X = df[["ad_spend"]]
y = df["revenue"]

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, random_state=42
)

model = LinearRegression()
model.fit(X_train, y_train)

y_pred = model.predict(X_test)
rmse = np.sqrt(mean_squared_error(y_test, y_pred))
r2 = r2_score(y_test, y_pred)

print(f"w={model.coef_[0]:.3f}, b={model.intercept_:.3f}")
print(f"RMSE={rmse:.3f}, R2={r2:.3f}")

Deliverable untuk Portofolio / Kerja

Kalau ini jadi proyek portofolio atau tugas kantor, output minimal yang bagus adalah: notebook berisi EDA singkat, training, metrik (RMSE, R²), plot residual, dan rekomendasi 2–3 perbaikan (misalnya menambah fitur musiman, log-transform target, atau mencoba Ridge/Lasso).