Machine Learning Dasar: Pengenalan & Konsep

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

# === DATASET: Prediksi Harga Rumah ===
np.random.seed(42)
n_samples = 200

luas = np.random.uniform(30, 200, n_samples)  # Luas rumah (m²)
harga = 50 * luas + 200 + np.random.normal(0, 300, n_samples)  # Harga (juta Rp)
# Formula: harga = 50 × luas + 200 + noise

df = pd.DataFrame({'luas_m2': luas, 'harga_jt': harga.round(1)})
print(f"Dataset: {df.shape[0]} baris, {df.shape[1]} kolom")
print(df.head())

# Pisahkan fitur (X) dan target (y)
X = df[['luas_m2']].values    # 2D array (fitur)
y = df['harga_jt'].values      # 1D array (target)

# Split data: 80% training, 20% testing
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)
print(f"\nTraining: {len(X_train)} samples")
print(f"Testing:  {len(X_test)} samples")

# Buat dan latih model
model = LinearRegression()
model.fit(X_train, y_train)

# Koefisien model
print(f"\nModel: Harga = {model.coef_[0]:.2f} × Luas + {model.intercept_:.2f}")

# Prediksi
y_pred = model.predict(X_test)

# Evaluasi
mae = mean_absolute_error(y_test, y_pred)
rmse = np.sqrt(mean_squared_error(y_test, y_pred))
r2 = r2_score(y_test, y_pred)
print(f"\nEvaluasi Model:")
print(f"  MAE  (Mean Absolute Error):  {mae:.2f} juta Rp")
print(f"  RMSE (Root Mean Sq Error):   {rmse:.2f} juta Rp")
print(f"  R² Score:                     {r2:.4f}")
# R² = 1.0 → prediksi sempurna, R² = 0 → model tidak berguna

# Visualisasi
plt.figure(figsize=(10, 6))
plt.scatter(X_test, y_test, alpha=0.6, color='blue', label='Data Aktual')
plt.plot(X_test, y_pred, color='red', linewidth=2, label='Prediksi Model')
plt.xlabel('Luas Rumah (m²)')
plt.ylabel('Harga (Juta Rp)')
plt.title(f'Linear Regression — R² = {r2:.4f}')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

# Multiple Linear Regression — lebih dari 1 fitur
np.random.seed(42)
n = 300

df_multi = pd.DataFrame({
    'luas_m2': np.random.uniform(30, 200, n),
    'kamar_tidur': np.random.randint(1, 6, n),
    'kamar_mandi': np.random.randint(1, 4, n),
    'usia_rumah': np.random.randint(0, 30, n),
})

# Buat target dengan formula yang lebih kompleks
df_multi['harga_jt'] = (
    50 * df_multi['luas_m2']
    + 100 * df_multi['kamar_tidur']
    + 80 * df_multi['kamar_mandi']
    - 10 * df_multi['usia_rumah']
    + 200
    + np.random.normal(0, 200, n)
).round(1)

# Split
X = df_multi[['luas_m2', 'kamar_tidur', 'kamar_mandi', 'usia_rumah']]
y = df_multi['harga_jt']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

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

# Evaluasi
y_pred_multi = model_multi.predict(X_test)
r2_multi = r2_score(y_test, y_pred_multi)

# Feature importance (koefisien)
print("Koefisien fitur:")
for name, coef in zip(X.columns, model_multi.coef_):
    print(f"  {name:15s}: {coef:+.2f}")
print(f"  Intercept: {model_multi.intercept_:.2f}")
print(f"\nR² Score: {r2_multi:.4f}")

import numpy as np
import pandas as pd
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import (accuracy_score, classification_report,
                             confusion_matrix)
from sklearn.preprocessing import StandardScaler

# === DATASET: Klasifikasi Bunga Iris ===
from sklearn.datasets import load_iris

iris = load_iris()
df_iris = pd.DataFrame(iris.data, columns=iris.feature_names)
df_iris['species'] = iris.target
df_iris['species_name'] = df_iris['species'].map({
    0: 'setosa', 1: 'versicolor', 2: 'virginica'
})

print("Dataset Iris:")
print(f"  Samples: {len(df_iris)}")
print(f"  Features: {iris.feature_names}")
print(f"  Classes: {iris.target_names}")
print(f"\nDistribusi kelas:")
print(df_iris['species_name'].value_counts())

# Pisahkan fitur dan target
X = df_iris[iris.feature_names].values
y = df_iris['species'].values

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

# Normalisasi fitur (penting untuk KNN!)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Train KNN dengan K=5
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train_scaled, y_train)

# Prediksi dan evaluasi
y_pred = knn.predict(X_test_scaled)
accuracy = accuracy_score(y_test, y_pred)

print(f"\n=== HASIL KLASIFIKASI KNN ===")
print(f"Akurasi: {accuracy:.4f} ({accuracy*100:.1f}%)")
print(f"\nClassification Report:")
print(classification_report(y_test, y_pred, target_names=iris.target_names))
print(f"Confusion Matrix:")
print(confusion_matrix(y_test, y_pred))

from sklearn.tree import DecisionTreeClassifier, export_text

# Decision Tree Classifier
dt = DecisionTreeClassifier(max_depth=4, random_state=42)
dt.fit(X_train, y_train)

y_pred_dt = dt.predict(X_test)
accuracy_dt = accuracy_score(y_test, y_pred_dt)
print(f"Decision Tree Accuracy: {accuracy_dt:.4f}")

# Tampilkan struktur pohon (text)
tree_rules = export_text(dt, feature_names=list(iris.feature_names))
print(f"\nStruktur Decision Tree:")
print(tree_rules[:500])

# Feature Importance — fitur mana yang paling penting
print(f"\nFeature Importance:")
for name, imp in sorted(zip(iris.feature_names, dt.feature_importances_),
                        key=lambda x: x[1], reverse=True):
    bar = '█' * int(imp * 50)
    print(f"  {name:25s}: {imp:.4f} {bar}")

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_blobs

# === DATASET: Generate synthetic data dengan 4 cluster ===
X_blobs, y_true = make_blobs(
    n_samples=300,
    centers=4,
    cluster_std=0.8,
    random_state=42
)

print(f"Dataset: {X_blobs.shape[0]} samples, {X_blobs.shape[1]} features")

# Normalisasi
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X_blobs)

# K-Means dengan K=4
kmeans = KMeans(n_clusters=4, random_state=42, n_init=10)
kmeans.fit(X_scaled)

labels = kmeans.labels_
centroids = kmeans.cluster_centers_

print(f"\nJumlah anggota per cluster:")
for i in range(4):
    print(f"  Cluster {i}: {(labels == i).sum()} samples")
print(f"Inertia (total within-cluster SS): {kmeans.inertia_:.2f}")

# Visualisasi
plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)
plt.scatter(X_blobs[:, 0], X_blobs[:, 1], c=y_true, cmap='viridis',
            s=30, alpha=0.7)
plt.title('Data Asli (True Labels)')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')

plt.subplot(1, 2, 2)
plt.scatter(X_blobs[:, 0], X_blobs[:, 1], c=labels, cmap='viridis',
            s=30, alpha=0.7)
# Plot centroids
centroids_original = scaler.inverse_transform(centroids)
plt.scatter(centroids_original[:, 0], centroids_original[:, 1],
            c='red', marker='X', s=200, edgecolors='black', linewidths=2,
            label='Centroids')
plt.title('K-Means Clustering (K=4)')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.legend()

plt.tight_layout()
plt.show()

# Elbow Method: Cari K optimal
inertias = []
K_range = range(1, 11)

for k in K_range:
    km = KMeans(n_clusters=k, random_state=42, n_init=10)
    km.fit(X_scaled)
    inertias.append(km.inertia_)

# Plot Elbow Curve
plt.figure(figsize=(10, 5))
plt.plot(K_range, inertias, 'bo-', linewidth=2, markersize=8)
plt.xlabel('Jumlah Cluster (K)')
plt.ylabel('Inertia (Within-Cluster Sum of Squares)')
plt.title('Elbow Method — Menentukan K Optimal')
plt.xticks(K_range)
plt.grid(True, alpha=0.3)

# Tambahkan anotasi "elbow"
plt.annotate('Elbow Point (K optimal)',
             xy=(4, inertias[3]),
             xytext=(6, inertias[1]),
             arrowprops=dict(arrowstyle='->', color='red', lw=2),
             fontsize=12, color='red', fontweight='bold')
plt.tight_layout()
plt.show()

# Interpretasi: Pilih K di "siku" kurva — titik di mana
# penurunan inertia mulai melambat secara signifikan
print("Inertia per K:")
for k, inertia in zip(K_range, inertias):
    print(f"  K={k:2d}: {inertia:.2f}")

from sklearn.model_selection import cross_val_score, KFold
from sklearn.ensemble import RandomForestClassifier

# K-Fold Cross Validation: evaluasi lebih robust
model = RandomForestClassifier(n_estimators=100, random_state=42)

# 5-Fold CV
cv_scores = cross_val_score(model, X, y, cv=5, scoring='accuracy')

print(f"5-Fold Cross Validation Results:")
print(f"  Scores per fold: {cv_scores.round(4)}")
print(f"  Mean Accuracy:   {cv_scores.mean():.4f}")
print(f"  Std Deviation:   {cv_scores.std():.4f}")
print(f"  95% CI:          [{cv_scores.mean()-2*cv_scores.std():.4f}, "
      f"{cv_scores.mean()+2*cv_scores.std():.4f}]")

# Visualisasi
plt.figure(figsize=(8, 4))
plt.bar(range(1, 6), cv_scores, color='steelblue', edgecolor='white')
plt.axhline(cv_scores.mean(), color='red', linestyle='--',
            label=f'Mean: {cv_scores.mean():.4f}')
plt.xlabel('Fold')
plt.ylabel('Accuracy')
plt.title('5-Fold Cross Validation Scores')
plt.legend()
plt.ylim(cv_scores.min() - 0.05, 1.0)
plt.tight_layout()
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score

# Generate non-linear data
np.random.seed(42)
X = np.sort(np.random.uniform(0, 10, 30)).reshape(-1, 1)
y = np.sin(X.ravel()) * 5 + np.random.normal(0, 0.8, 30)

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

plt.figure(figsize=(15, 4))

# Plot 3 model dengan degree berbeda
for i, degree in enumerate([1, 4, 15], 1):
    plt.subplot(1, 3, i)

    # Polynomial features
    poly = PolynomialFeatures(degree=degree)
    X_train_poly = poly.fit_transform(X_train)
    X_test_poly = poly.transform(X_test)

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

    # Predict
    X_plot = np.linspace(0, 10, 200).reshape(-1, 1)
    y_plot = model.predict(poly.transform(X_plot))
    y_train_pred = model.predict(X_train_poly)
    y_test_pred = model.predict(X_test_poly)

    r2_train = r2_score(y_train, y_train_pred)
    r2_test = r2_score(y_test, y_test_pred)

    # Plot
    plt.scatter(X_train, y_train, color='blue', s=40, label='Train', zorder=3)
    plt.scatter(X_test, y_test, color='red', s=40, label='Test', zorder=3)
    plt.plot(X_plot, y_plot, color='green', linewidth=2, label='Model')

    label = {1: 'Underfitting', 4: 'Good Fit', 15: 'Overfitting'}
    plt.title(f'Degree {degree} — {label[degree]}\n'
              f'R² train={r2_train:.3f}, test={r2_test:.3f}')
    plt.legend(fontsize=8)
    plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# ===== POLA STANDAR SCIKIT-LEARN =====

# 1. Import model yang dibutuhkan
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report

# 2. Siapkan data
X = df[['feature1', 'feature2', 'feature3']].values
y = df['target'].values

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

# 4. Preprocessing (scaling)
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)   # fit + transform pada train
X_test = scaler.transform(X_test)         # HANYA transform pada test!

# 5. Buat model
model = RandomForestClassifier(
    n_estimators=100,    # Jumlah trees
    max_depth=10,        # Kedalaman maksimum tiap tree
    random_state=42
)

# 6. Training (fit)
model.fit(X_train, y_train)

# 7. Prediksi
y_pred = model.predict(X_test)
y_proba = model.predict_proba(X_test)  # Probabilitas per kelas

# 8. Evaluasi
accuracy = accuracy_score(y_test, y_pred)
print(f"Akurasi: {accuracy:.4f}")
print(classification_report(y_test, y_pred))

# 9. Menggunakan model untuk prediksi data baru
data_baru = [[5.1, 3.5, 1.4]]  # Data baru
data_baru_scaled = scaler.transform(data_baru)
prediksi = model.predict(data_baru_scaled)
print(f"Prediksi: {prediksi}")

from sklearn.model_selection import GridSearchCV
from sklearn.ensemble import RandomForestClassifier

# Definisikan hyperparameter yang ingin dicoba
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [5, 10, 15, None],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4]
}

# GridSearch dengan 5-fold CV
grid_search = GridSearchCV(
    estimator=RandomForestClassifier(random_state=42),
    param_grid=param_grid,
    cv=5,                    # 5-fold cross validation
    scoring='accuracy',      # Metrik evaluasi
    n_jobs=-1,               # Gunakan semua CPU cores
    verbose=1
)

grid_search.fit(X_train, y_train)

# Hasil terbaik
print(f"Best Parameters: {grid_search.best_params_}")
print(f"Best CV Score: {grid_search.best_score_:.4f}")

# Model terbaik
best_model = grid_search.best_estimator_
y_pred_best = best_model.predict(X_test)
print(f"Test Accuracy: {accuracy_score(y_test, y_pred_best):.4f}")