Linear Regression: Regresi Linier

# Simple Linear Regression (1 fitur):
# y = b0 + b1 * x
#
# Dimana:
#   y  = nilai prediksi (target)
#   b0 = intercept (titik potong sumbu Y)
#   b1 = slope (kemiringan garis)
#   x  = variabel input (fitur)
#
# Multiple Linear Regression (banyak fitur):
# y = b0 + b1*x1 + b2*x2 + b3*x3 + ... + bn*xn
#
# Dalam notasi vektor:
# y = X · β
#
# Dimana X adalah matriks fitur dan β adalah vektor koefisien

import numpy as np
import matplotlib.pyplot as plt

# Data: Luas rumah (m²) dan harga (juta Rp)
luas = np.array([36, 45, 50, 55, 60, 65, 70, 75, 80, 90, 100, 120])
harga = np.array([250, 300, 350, 380, 420, 450, 500, 530, 570, 650, 720, 850])

# ===== IMPLEMENTASI MANUAL (OLS) =====
n = len(luas)
x_mean = np.mean(luas)
y_mean = np.mean(harga)

# Hitung slope (b1) dan intercept (b0)
numerator = np.sum((luas - x_mean) * (harga - y_mean))
denominator = np.sum((luas - x_mean) ** 2)
b1 = numerator / denominator
b0 = y_mean - b1 * x_mean

print(f"Intercept (b0): {b0:.2f}")
print(f"Slope (b1): {b1:.2f}")
print(f"Persamaan: harga = {b0:.2f} + {b1:.2f} × luas")

# Prediksi
harga_prediksi = b0 + b1 * luas

# Visualisasi
plt.figure(figsize=(10, 6))
plt.scatter(luas, harga, color='blue', s=100, label='Data Aktual', zorder=5)
plt.plot(luas, harga_prediksi, 'r-', linewidth=2, label=f'Garis Regresi: y={b0:.1f}+{b1:.1f}x')
plt.xlabel('Luas Rumah (m²)', fontsize=12)
plt.ylabel('Harga (Juta Rp)', fontsize=12)
plt.title('Simple Linear Regression: Harga vs Luas Rumah', fontsize=14)
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

# Prediksi harga rumah baru
luas_baru = 85
harga_baru = b0 + b1 * luas_baru
print(f"\nPrediksi harga rumah {luas_baru} m²: Rp {harga_baru:.0f} juta")

import numpy as np

# Menghitung residual
residual = harga - harga_prediksi

print("Data, Prediksi, dan Residual:")
print(f"{'Luas':>6} {'Aktual':>8} {'Prediksi':>10} {'Residual':>10}")
print("-" * 38)
for i in range(len(luas)):
    print(f"{luas[i]:>6} {harga[i]:>8} {harga_prediksi[i]:>10.1f} {residual[i]:>10.1f}")

print(f"\nJumlah Kuadrat Residual (SSE): {np.sum(residual**2):.2f}")
print(f"Mean Squared Error (MSE): {np.mean(residual**2):.2f}")
print(f"Root Mean Squared Error (RMSE): {np.sqrt(np.mean(residual**2)):.2f}")

# R-squared (koefisien determinasi)
ss_res = np.sum((harga - harga_prediksi) ** 2)   # Sum of Squares Residual
ss_tot = np.sum((harga - np.mean(harga)) ** 2)    # Sum of Squares Total
r_squared = 1 - (ss_res / ss_tot)
print(f"R-squared: {r_squared:.4f}")
print(f"Interpretasi: {r_squared*100:.1f}% variasi harga bisa dijelaskan oleh luas rumah")

import numpy as np
import pandas as pd

# Dataset: Harga Rumah dengan beberapa fitur
np.random.seed(42)
n = 200

luas = np.random.uniform(30, 150, n)
kamar = np.random.randint(1, 5, n).astype(float)
lantai = np.random.randint(1, 4, n).astype(float)
jarak_kota = np.random.uniform(1, 30, n)

# Harga dipengaruhi oleh semua fitur + noise
harga = (
    50
    + 6.5 * luas
    + 30 * kamar
    + 45 * lantai
    - 5 * jarak_kota
    + np.random.normal(0, 50, n)  # noise/variabilitas
)

# Buat DataFrame
df = pd.DataFrame({
    'luas_m2': luas.round(1),
    'jumlah_kamar': kamar.astype(int),
    'jumlah_lantai': lantai.astype(int),
    'jarak_kota_km': jarak_kota.round(1),
    'harga_juta': harga.round(1)
})

print("Dataset Harga Rumah:")
print(df.head(10))
print(f"\nShape: {df.shape}")
print(f"\nStatistik Deskriptif:")
print(df.describe().round(1))

import numpy as np

# Persiapan data untuk Normal Equation
X = df[['luas_m2', 'jumlah_kamar', 'jumlah_lantai', 'jarak_kota_km']].values
y = df['harga_juta'].values

# Tambah kolom intercept (kolom berisi 1)
X_with_intercept = np.column_stack([np.ones(X.shape[0]), X])

# Normal Equation: β = (X^T X)^(-1) X^T y
beta = np.linalg.inv(X_with_intercept.T @ X_with_intercept) @ X_with_intercept.T @ y

print("Koefisien (dari Normal Equation):")
print(f"  Intercept:  {beta[0]:.2f}")
print(f"  Luas:       {beta[1]:.2f}")
print(f"  Kamar:      {beta[2]:.2f}")
print(f"  Lantai:     {beta[3]:.2f}")
print(f"  Jarak Kota: {beta[4]:.2f}")

# Prediksi
y_pred = X_with_intercept @ beta

# Evaluasi
ss_res = np.sum((y - y_pred) ** 2)
ss_tot = np.sum((y - np.mean(y)) ** 2)
r2 = 1 - ss_res / ss_tot
rmse = np.sqrt(np.mean((y - y_pred) ** 2))

print(f"\nR² Score: {r2:.4f}")
print(f"RMSE: {rmse:.2f} juta")
print(f"\nInterpretasi:")
print(f"  - Luas naik 1 m² → harga naik Rp {beta[1]:.1f} juta")
print(f"  - 1 kamar tambahan → harga naik Rp {beta[2]:.1f} juta")
print(f"  - 1 lantai tambahan → harga naik Rp {beta[3]:.1f} juta")
print(f"  - Jarak kota +1 km → harga turun Rp {abs(beta[4]):.1f} juta")

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

# Contoh data aktual dan prediksi
y_actual = np.array([100, 150, 200, 250, 300, 350, 400])
y_predicted = np.array([110, 140, 210, 240, 310, 340, 420])

# ===== MAE (Mean Absolute Error) =====
mae = mean_absolute_error(y_actual, y_predicted)
print(f"MAE:  {mae:.2f}")
print(f"  → Rata-rata prediksi meleset {mae:.2f} unit dari aktual")

# ===== MSE (Mean Squared Error) =====
mse = mean_squared_error(y_actual, y_predicted)
print(f"\nMSE:  {mse:.2f}")
print(f"  → Rata-rata kuadrat error: {mse:.2f}")

# ===== RMSE (Root Mean Squared Error) =====
rmse = np.sqrt(mse)
print(f"\nRMSE: {rmse:.2f}")
print(f"  → Rata-rata error: {rmse:.2f} unit (satuan sama dengan target)")

# ===== R² Score =====
r2 = r2_score(y_actual, y_predicted)
print(f"\nR²:   {r2:.4f}")
print(f"  → Model menjelaskan {r2*100:.1f}% variasi data")

# ===== MAPE (Mean Absolute Percentage Error) =====
mape = np.mean(np.abs((y_actual - y_predicted) / y_actual)) * 100
print(f"\nMAPE: {mape:.2f}%")
print(f"  → Rata-rata error {mape:.1f}% dari nilai aktual")

# ===== Manual calculation untuk pemahaman =====
print("\n===== Detail Perhitungan =====")
residuals = y_actual - y_predicted
print(f"{'Aktual':>8} {'Prediksi':>10} {'Residual':>10} {'|Error|':>10} {'Error²':>10}")
print("-" * 52)
for a, p in zip(y_actual, y_predicted):
    r = a - p
    print(f"{a:>8} {p:>10} {r:>10} {abs(r):>10} {r**2:>10.0f}")

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

# Split data: 80% train, 20% test
X = df[['luas_m2', 'jumlah_kamar', 'jumlah_lantai', 'jarak_kota_km']]
y = df['harga_juta']

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

print(f"Data train: {X_train.shape[0]} sampel")
print(f"Data test:  {X_test.shape[0]} sampel")

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

# Evaluasi
y_train_pred = model.predict(X_train)
y_test_pred = model.predict(X_test)

print(f"\n--- Evaluasi ---")
print(f"Train R²: {r2_score(y_train, y_train_pred):.4f}")
print(f"Test R²:  {r2_score(y_test, y_test_pred):.4f}")
print(f"Train RMSE: {np.sqrt(mean_squared_error(y_train, y_train_pred)):.2f}")
print(f"Test RMSE:  {np.sqrt(mean_squared_error(y_test, y_test_pred)):.2f}")

# Cross-validation (5-fold)
cv_scores = cross_val_score(model, X, y, cv=5, scoring='r2')
print(f"\nCross-Validation R² (5-fold):")
print(f"  Scores: {cv_scores.round(4)}")
print(f"  Mean: {cv_scores.mean():.4f} ± {cv_scores.std():.4f}")

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
import matplotlib.pyplot as plt

# ===== 1. PERSIAPAN DATA =====
np.random.seed(42)
n = 300

data = pd.DataFrame({
    'luas_m2': np.random.uniform(30, 200, n),
    'kamar': np.random.randint(1, 6, n),
    'garasi': np.random.randint(0, 3, n),
    'usia_rumah': np.random.uniform(0, 30, n),
    'jarak_sekolah': np.random.uniform(0.5, 10, n),
})

data['harga'] = (
    100
    + 5.5 * data['luas_m2']
    + 25 * data['kamar']
    + 40 * data['garasi']
    - 3 * data['usia_rumah']
    - 8 * data['jarak_sekolah']
    + np.random.normal(0, 40, n)
)

print("Sample data:")
print(data.head())

# ===== 2. SPLIT DATA =====
feature_cols = ['luas_m2', 'kamar', 'garasi', 'usia_rumah', 'jarak_sekolah']
X = data[feature_cols]
y = data['harga']

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

# ===== 3. SCALING (opsional tapi recommended) =====
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# ===== 4. LATIH MODEL =====
model = LinearRegression()
model.fit(X_train_scaled, y_train)

# ===== 5. EVALUASI =====
y_pred_train = model.predict(X_train_scaled)
y_pred_test = model.predict(X_test_scaled)

print("\n=== HASIL EVALUASI ===")
print(f"{'Metrik':<15} {'Train':>10} {'Test':>10}")
print("-" * 37)
print(f"{'R² Score':<15} {r2_score(y_train, y_pred_train):>10.4f} {r2_score(y_test, y_pred_test):>10.4f}")
print(f"{'MAE':<15} {mean_absolute_error(y_train, y_pred_train):>10.2f} {mean_absolute_error(y_test, y_pred_test):>10.2f}")
print(f"{'RMSE':<15} {np.sqrt(mean_squared_error(y_train, y_pred_train)):>10.2f} {np.sqrt(mean_squared_error(y_test, y_pred_test)):>10.2f}")

# ===== 6. INTERPRETASI KOEFISIEN =====
print("\n=== KOEFISIEN MODEL ===")
for feat, coef in zip(feature_cols, model.coef_):
    print(f"  {feat:<20}: {coef:>8.3f}")
print(f"  {'Intercept':<20}: {model.intercept_:>8.3f}")

# ===== 7. VISUALISASI =====
fig, axes = plt.subplots(1, 2, figsize=(14, 5))

# Actual vs Predicted
axes[0].scatter(y_test, y_pred_test, alpha=0.5, color='steelblue')
axes[0].plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()],
             'r--', linewidth=2, label='Perfect Prediction')
axes[0].set_xlabel('Harga Aktual (Juta Rp)')
axes[0].set_ylabel('Harga Prediksi (Juta Rp)')
axes[0].set_title('Actual vs Predicted')
axes[0].legend()
axes[0].grid(True, alpha=0.3)

# Residual plot
residuals = y_test - y_pred_test
axes[1].scatter(y_pred_test, residuals, alpha=0.5, color='coral')
axes[1].axhline(y=0, color='black', linestyle='--', linewidth=1)
axes[1].set_xlabel('Prediksi (Juta Rp)')
axes[1].set_ylabel('Residual')
axes[1].set_title('Residual Plot')
axes[1].grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('linear_regression_evaluation.png', dpi=150)
plt.show()

# Prediksi harga rumah baru
rumah_baru = pd.DataFrame({
    'luas_m2': [120],
    'kamar': [3],
    'garasi': [2],
    'usia_rumah': [5],
    'jarak_sekolah': [2.0]
})

# Jangan lupa scaling!
rumah_scaled = scaler.transform(rumah_baru)
harga_pred = model.predict(rumah_scaled)

print(f"Spesifikasi Rumah:")
for col in feature_cols:
    print(f"  {col}: {rumah_baru[col].values[0]}")
print(f"\nPrediksi Harga: Rp {harga_pred[0]:,.1f} juta")
print(f"               = Rp {harga_pred[0]*1_000_000:,.0f}")

import pandas as pd
from sklearn.preprocessing import OneHotEncoder, LabelEncoder

# Data dengan fitur kategorikal
df_rumah = pd.DataFrame({
    'luas': [80, 120, 60, 150, 90],
    'harga': [500, 800, 350, 1000, 600],
    'tipe': ['rumah', 'apartemen', 'rumah', 'apartemen', 'rumah'],
    'lokasi': ['jakarta', 'bandung', 'surabaya', 'jakarta', 'bandung']
})

# ===== One-Hot Encoding (RECOMMENDED untuk Linear Regression) =====
df_encoded = pd.get_dummies(df_rumah, columns=['tipe', 'lokasi'], drop_first=True)
print("One-Hot Encoded:")
print(df_encoded)

# Atau dengan sklearn:
encoder = OneHotEncoder(sparse_output=False, drop='first')
tipe_encoded = encoder.fit_transform(df_rumah[['tipe', 'lokasi']])
print(f"\nEncoded shape: {tipe_encoded.shape}")
print(f"Feature names: {encoder.get_feature_names_out()}")

from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.pipeline import Pipeline
import numpy as np

# Data dengan hubungan non-linier (kuadratik)
np.random.seed(42)
X = np.random.uniform(-3, 3, 100).reshape(-1, 1)
y = 2 * X.ravel()**2 + 3 * X.ravel() + 5 + np.random.normal(0, 2, 100)

# Pipeline: Polynomial Features + Linear Regression
# Ini mengubah x menjadi [1, x, x²] — tapi tetap "linear" dalam koefisien!
poly_model = Pipeline([
    ('poly', PolynomialFeatures(degree=2, include_bias=False)),
    ('linear', LinearRegression())
])

poly_model.fit(X, y)
r2 = poly_model.score(X, y)
print(f"R² dengan Polynomial Features (degree=2): {r2:.4f}")

# Lihat fitur yang dibuat
poly = PolynomialFeatures(degree=2, include_bias=False)
X_poly = poly.fit_transform(X)
print(f"\nFitur asli: 1 kolom (x)")
print(f"Fitur polinomial: {X_poly.shape[1]} kolom (x, x²)")
print(f"Feature names: {poly.get_feature_names_out()}")

from sklearn.linear_model import Ridge, Lasso, ElasticNet
from sklearn.model_selection import cross_val_score
from sklearn.preprocessing import StandardScaler
import numpy as np

# Asumsikan X_train, X_test, y_train, y_test sudah ada
scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test)

# ===== RIDGE REGRESSION =====
ridge = Ridge(alpha=1.0)  # alpha = λ (kekuatan penalti)
ridge.fit(X_train_s, y_train)

print("=== RIDGE REGRESSION ===")
print(f"R² Train: {ridge.score(X_train_s, y_train):.4f}")
print(f"R² Test:  {ridge.score(X_test_s, y_test):.4f}")
print("Koefisien:")
for name, coef in zip(feature_cols, ridge.coef_):
    print(f"  {name:<20}: {coef:>8.3f}")

# ===== LASSO REGRESSION =====
lasso = Lasso(alpha=1.0)
lasso.fit(X_train_s, y_train)

print("\n=== LASSO REGRESSION ===")
print(f"R² Train: {lasso.score(X_train_s, y_train):.4f}")
print(f"R² Test:  {lasso.score(X_test_s, y_test):.4f}")
print("Koefisien:")
for name, coef in zip(feature_cols, lasso.coef_):
    status = "← dieliminasi!" if abs(coef) < 0.01 else ""
    print(f"  {name:<20}: {coef:>8.3f} {status}")

# ===== ELASTIC NET =====
elastic = ElasticNet(alpha=1.0, l1_ratio=0.5)  # l1_ratio: rasio L1 vs L2
elastic.fit(X_train_s, y_train)

print(f"\n=== ELASTIC NET ===")
print(f"R² Train: {elastic.score(X_train_s, y_train):.4f}")
print(f"R² Test:  {elastic.score(X_test_s, y_test):.4f}")

# ===== MENCARI ALPHA TERBAIK (Grid Search) =====
from sklearn.linear_model import RidgeCV

alphas = [0.001, 0.01, 0.1, 1.0, 10.0, 100.0]
ridge_cv = RidgeCV(alphas=alphas, cv=5)
ridge_cv.fit(X_train_s, y_train)

print(f"\n=== RIDGE CV (Best Alpha) ===")
print(f"Best alpha: {ridge_cv.alpha_}")
print(f"Best R²: {ridge_cv.score(X_test_s, y_test):.4f}")