Evaluasi Model dengan Function sklearn.metrics

Dalam proses Machine Learning, setelah model selesai dilatih dan menghasilkan prediksi, kita perlu mengetahui seberapa baik performa model tersebut.

Sebelumnya kita telah mempelajari beberapa cara untuk melakukan evaluasi model:

Menggunakan metode bawaan model seperti .score().
Menggunakan parameter scoring pada cross_val_score().
Menggunakan fungsi evaluasi dari modul sklearn.metrics.

Pada materi ini kita akan fokus pada cara ketiga, yaitu menggunakan berbagai fungsi yang tersedia di:

sklearn.metrics

Pendekatan ini memberikan kontrol yang lebih jelas terhadap metrik yang ingin digunakan untuk mengevaluasi model.

Secara umum, proses evaluasi dapat digambarkan sebagai:

Data
  │
  ├── X_test
  │
  └── y_test
       │
       ▼
     Model
       │
       ▼
   y_pred / y_preds
       │
       ▼
┌──────────────────────┐
│   sklearn.metrics    │
├──────────────────────┤
│ Accuracy             │
│ Precision            │
│ Recall               │
│ F1                   │
│ R²                   │
│ MAE                  │
│ MSE                  │
└──────────────────────┘
       │
       ▼
 Evaluation Score

Modul `sklearn.metrics`

Scikit-Learn menyediakan berbagai fungsi evaluasi melalui modul:

sklearn.metrics

Kita dapat mengimpor fungsi yang diperlukan secara langsung.

Contoh:

from sklearn.metrics import accuracy_score

Atau beberapa fungsi sekaligus:

from sklearn.metrics import (
    accuracy_score,
    precision_score,
    recall_score,
    f1_score
)

Untuk regresi:

from sklearn.metrics import (
    r2_score,
    mean_absolute_error,
    mean_squared_error
)

Konsep Dasar `y_true` dan `y_pred`

Hampir semua fungsi evaluasi pada sklearn.metrics bekerja dengan membandingkan dua hal:

y_true
   │
   │ dibandingkan
   ▼
y_pred

`y_true`

y_true adalah nilai sebenarnya atau ground truth.

Biasanya berasal dari:

y_test

`y_pred`

y_pred adalah hasil prediksi model.

Biasanya diperoleh dari:

y_preds = model.predict(X_test)

Contohnya:

y_preds = clf.predict(X_test)

Kemudian:

accuracy_score(y_test, y_preds)

Artinya:

y_test
  ↓
Nilai sebenarnya

y_preds
  ↓
Nilai prediksi model

       ↓

accuracy_score()
       ↓
   Evaluasi

Classification Metrics

Classification metrics digunakan untuk mengevaluasi model yang menghasilkan kelas atau label diskrit.

Contohnya:

0 = Tidak memiliki penyakit
1 = Memiliki penyakit

atau:

0 = Tidak spam
1 = Spam

Beberapa metrik klasifikasi yang umum digunakan:

Fungsi	Metrik
`accuracy_score()`	Accuracy
`precision_score()`	Precision
`recall_score()`	Recall
`f1_score()`	F1-score

`accuracy_score()`

Accuracy mengukur proporsi prediksi yang benar dibandingkan dengan seluruh data.

Rumus:

Accuracy = \frac{TP + TN}{TP + TN + FP + FN}

Keterangan:

TP = True Positive
TN = True Negative
FP = False Positive
FN = False Negative

Contoh:

from sklearn.metrics import accuracy_score

accuracy = accuracy_score(
    y_test,
    y_preds
)

print(accuracy)

Jika hasil:

0.82

maka model memiliki accuracy sebesar:

82%

Untuk menampilkan sebagai persentase:

print(f"Accuracy: {accuracy * 100:.2f}%")

Output:

Accuracy: 82.00%

`precision_score()`

Precision menjawab pertanyaan:

Dari seluruh data yang diprediksi sebagai positif, berapa banyak yang benar-benar positif?

Rumus:

Precision = \frac{TP}{TP + FP}

Precision sangat berkaitan dengan False Positive.

Jika False Positive tinggi, precision akan menurun.

Contoh:

from sklearn.metrics import precision_score

precision = precision_score(
    y_test,
    y_preds
)

print(f"Precision: {precision:.2f}")

Misalnya:

Precision: 0.85

Artinya, sekitar 85% dari prediksi positif model merupakan prediksi positif yang benar.

`recall_score()`

Recall menjawab pertanyaan:

Dari seluruh data yang sebenarnya positif, berapa banyak yang berhasil ditemukan oleh model?

Rumus:

Recall = \frac{TP}{TP + FN}

Recall sangat berkaitan dengan False Negative.

Jika False Negative tinggi, recall akan menurun.

Contoh:

from sklearn.metrics import recall_score

recall = recall_score(
    y_test,
    y_preds
)

print(f"Recall: {recall:.2f}")

Misalnya:

Recall: 0.80

Artinya, model berhasil menemukan sekitar 80% dari seluruh kasus positif yang sebenarnya.

`f1_score()`

F1-score merupakan harmonic mean antara precision dan recall.

Rumus:

F1 = 2 \times \frac{Precision \times Recall}{Precision + Recall}

F1-score berguna ketika kita ingin mempertimbangkan precision dan recall secara bersamaan.

Contoh:

from sklearn.metrics import f1_score

f1 = f1_score(
    y_test,
    y_preds
)

print(f"F1 Score: {f1:.2f}")

Misalnya:

F1 Score: 0.82

F1-score tidak hanya melihat jumlah prediksi benar secara keseluruhan, tetapi juga mempertimbangkan keseimbangan antara precision dan recall.

Workflow Evaluasi Classification

Secara umum, workflow klasifikasi menggunakan sklearn.metrics adalah:

Dataset
   │
   ▼
Pisahkan X dan y
   │
   ▼
Train/Test Split
   │
   ├── X_train
   ├── X_test
   ├── y_train
   └── y_test
        │
        ▼
     Training
        │
        ▼
      Model
        │
        ▼
     predict()
        │
        ▼
     y_preds
        │
        ▼
 sklearn.metrics
        │
        ├── Accuracy
        ├── Precision
        ├── Recall
        └── F1

Contoh Lengkap Classification

Berikut contoh workflow lengkap menggunakan RandomForestClassifier.

import numpy as np

from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import (
    accuracy_score,
    precision_score,
    recall_score,
    f1_score
)
from sklearn.model_selection import train_test_split

# 1. Menyiapkan data
np.random.seed(42)

X = heart_disease.drop("target", axis=1)
y = heart_disease["target"]

# 2. Membagi data train dan test
X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.2,
    random_state=42,
    stratify=y
)

# 3. Membuat model
clf = RandomForestClassifier(
    n_estimators=100,
    random_state=42
)

# 4. Training model
clf.fit(X_train, y_train)

# 5. Membuat prediksi
y_preds = clf.predict(X_test)

# 6. Menghitung evaluation metrics
accuracy = accuracy_score(y_test, y_preds)
precision = precision_score(y_test, y_preds)
recall = recall_score(y_test, y_preds)
f1 = f1_score(y_test, y_preds)

# 7. Menampilkan hasil
print("Metrik Evaluasi Klasifikasi")
print(f"Accuracy : {accuracy * 100:.2f}%")
print(f"Precision: {precision:.2f}")
print(f"Recall   : {recall:.2f}")
print(f"F1 Score : {f1:.2f}")

Contoh output:

Metrik Evaluasi Klasifikasi
Accuracy : 82.00%
Precision: 0.84
Recall   : 0.81
F1 Score : 0.82

Nilai tersebut hanya contoh. Hasil aktual bergantung pada dataset, pembagian data, model, dan konfigurasi yang digunakan.

Regression Metrics

Regression metrics digunakan untuk mengevaluasi model yang menghasilkan nilai kontinu.

Contohnya:

Prediksi harga rumah
Prediksi suhu
Prediksi penjualan
Prediksi jumlah permintaan
Prediksi waktu

Beberapa metrik regresi yang umum digunakan:

Fungsi	Metrik
`r2_score()`	R²
`mean_absolute_error()`	MAE
`mean_squared_error()`	MSE

`r2_score()`

R² atau Coefficient of Determination mengukur seberapa baik variasi pada target dapat dijelaskan oleh model dibandingkan dengan baseline berupa prediksi rata-rata target.

Contoh:

from sklearn.metrics import r2_score

r2 = r2_score(
    y_test,
    y_preds
)

print(f"R² Score: {r2:.4f}")

Interpretasi umum:

R² = 1

berarti prediksi sempurna pada data evaluasi.

R² = 0

berarti performa model setara dengan baseline yang selalu memprediksi rata-rata target.

Pada data evaluasi yang tidak terlihat sebelumnya, R² juga dapat bernilai negatif.

Contohnya:

R² = -0.25

Ini menunjukkan bahwa model memiliki performa yang lebih buruk daripada baseline prediksi rata-rata menurut definisi R² pada data evaluasi tersebut.

`mean_absolute_error()`

MAE atau Mean Absolute Error menghitung rata-rata nilai absolut dari error prediksi.

Rumus:

MAE = \frac{1}{n}\sum_{i=1}^{n}|y_i-\hat{y}_i|

Contoh:

from sklearn.metrics import mean_absolute_error

mae = mean_absolute_error(
    y_test,
    y_preds
)

print(f"MAE: {mae:.4f}")

Misalnya:

MAE: 2.3145

Artinya, rata-rata absolute error prediksi adalah sekitar 2.31 satuan target.

Jika target adalah harga rumah dalam juta rupiah, maka interpretasinya mengikuti satuan target tersebut.

MAE memiliki karakteristik:

MAE lebih kecil → lebih baik
MAE = 0         → prediksi sempurna

`mean_squared_error()`

MSE atau Mean Squared Error menghitung rata-rata kuadrat error.

Rumus:

MSE = \frac{1}{n}\sum_{i=1}^{n}(y_i-\hat{y}_i)^2

Contoh:

from sklearn.metrics import mean_squared_error

mse = mean_squared_error(
    y_test,
    y_preds
)

print(f"MSE: {mse:.4f}")

MSE memberikan penalti lebih besar terhadap error yang besar karena error dikuadratkan.

Contoh:

Error = 2
Squared Error = 4

sedangkan:

Error = 10
Squared Error = 100

Oleh karena itu, MSE lebih sensitif terhadap error besar dibandingkan MAE.

Karakteristik MSE:

MSE lebih kecil → lebih baik
MSE = 0         → prediksi sempurna

RMSE dari MSE

Jika kita ingin mengubah MSE kembali ke skala target, kita dapat menggunakan akar kuadrat:

RMSE = \sqrt{MSE}

Contoh:

import numpy as np

rmse = np.sqrt(mse)

print(f"RMSE: {rmse:.4f}")

Misalnya:

MSE  = 9.00
RMSE = 3.00

RMSE memiliki satuan yang sama dengan target sehingga sering lebih mudah diinterpretasikan dibandingkan MSE.

Workflow Evaluasi Regression

Workflow regresi menggunakan sklearn.metrics dapat digambarkan sebagai:

Dataset
   │
   ▼
Pisahkan X dan y
   │
   ▼
Train/Test Split
   │
   ├── X_train
   ├── X_test
   ├── y_train
   └── y_test
        │
        ▼
     Training
        │
        ▼
      Model
        │
        ▼
     predict()
        │
        ▼
     y_preds
        │
        ▼
 sklearn.metrics
        │
        ├── R²
        ├── MAE
        ├── MSE
        └── RMSE

Contoh Lengkap Regression

Berikut contoh menggunakan RandomForestRegressor.

import numpy as np

from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import (
    r2_score,
    mean_absolute_error,
    mean_squared_error
)
from sklearn.model_selection import train_test_split

# 1. Menyiapkan data
np.random.seed(42)

X = housing_df.drop("target", axis=1)
y = housing_df["target"]

# 2. Membagi data train dan test
X_train, X_test, y_train, y_test = train_test_split(
    X,
    y,
    test_size=0.2,
    random_state=42
)

# 3. Membuat model
model = RandomForestRegressor(
    n_estimators=100,
    random_state=42
)

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

# 5. Membuat prediksi
y_preds = model.predict(X_test)

# 6. Menghitung evaluation metrics
r2 = r2_score(y_test, y_preds)
mae = mean_absolute_error(y_test, y_preds)
mse = mean_squared_error(y_test, y_preds)
rmse = np.sqrt(mse)

# 7. Menampilkan hasil
print("Metrik Evaluasi Regresi")
print(f"R²  : {r2:.4f}")
print(f"MAE : {mae:.4f}")
print(f"MSE : {mse:.4f}")
print(f"RMSE: {rmse:.4f}")

Contoh output:

Metrik Evaluasi Regresi
R²  : 0.7800
MAE : 2.3100
MSE : 8.4200
RMSE: 2.9017

Nilai tersebut hanya contoh untuk menunjukkan format hasil evaluasi.

Single Train/Test Split vs Cross-Validation

Terdapat perbedaan penting antara evaluasi menggunakan satu kali train/test split dan cross-validation.

Evaluasi	Cara Kerja	Kelebihan	Kekurangan
Single Train/Test Split	Model dievaluasi pada satu test set	Cepat dan sederhana	Hasil dapat bergantung pada pembagian data
Cross-Validation	Model dievaluasi pada beberapa fold	Memberikan beberapa hasil evaluasi dan gambaran performa yang lebih stabil	Membutuhkan komputasi lebih banyak

Single Train/Test Split

Pada single train/test split, dataset dibagi satu kali.

Contoh:

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

Kemudian model dilatih:

model.fit(X_train, y_train)

Dan dievaluasi:

y_preds = model.predict(X_test)

r2 = r2_score(y_test, y_preds)

Alurnya:

Dataset
   │
   ▼
Train/Test Split
   │
   ├── Training Data
   │       ↓
   │     Model
   │       ↓
   │
   └── Test Data
           ↓
       Evaluation

Kelebihan pendekatan ini adalah sederhana dan cepat.

Kekurangannya adalah hasil evaluasi dapat berubah jika pembagian data berubah.

Cross-Validation

Pada cross-validation, dataset dibagi menjadi beberapa fold.

Misalnya:

from sklearn.model_selection import cross_val_score

scores = cross_val_score(
    model,
    X,
    y,
    cv=5,
    scoring="r2"
)

Model dievaluasi sebanyak 5 kali.

Contoh hasil:

Fold 1 → 0.74
Fold 2 → 0.79
Fold 3 → 0.76
Fold 4 → 0.81
Fold 5 → 0.77

Kemudian kita dapat menghitung rata-rata:

np.mean(scores)

Contoh:

0.774

Cross-validation memberikan beberapa hasil evaluasi sehingga kita dapat melihat variasi performa antar-fold.

Hubungan `sklearn.metrics` dengan Cross-Validation

Kedua pendekatan ini sebenarnya tidak saling bertentangan.

sklearn.metrics dapat digunakan untuk mengevaluasi hasil prediksi secara langsung:

y_preds = model.predict(X_test)

accuracy_score(y_test, y_preds)

Sedangkan cross_val_score() mengotomatisasi proses evaluasi pada beberapa fold:

cross_val_score(
    model,
    X,
    y,
    cv=5,
    scoring="accuracy"
)

Secara sederhana:

sklearn.metrics
      │
      ▼
y_true + y_pred
      │
      ▼
Satu hasil evaluasi

Sedangkan:

cross_val_score()
      │
      ▼
 Beberapa fold
      │
      ▼
   Scoring
      │
      ▼
Beberapa hasil evaluasi

Kapan Menggunakan `sklearn.metrics`?

Fungsi sklearn.metrics sangat berguna ketika kita ingin mengetahui performa model pada hasil prediksi tertentu.

Contohnya:

y_preds = model.predict(X_test)

accuracy_score(y_test, y_preds)

Kita juga dapat menghitung beberapa metrik sekaligus:

accuracy_score(y_test, y_preds)
precision_score(y_test, y_preds)
recall_score(y_test, y_preds)
f1_score(y_test, y_preds)

Untuk regresi:

r2_score(y_test, y_preds)
mean_absolute_error(y_test, y_preds)
mean_squared_error(y_test, y_preds)

Dengan demikian, kita dapat memilih sendiri metrik yang ingin dianalisis.

Memilih Metrik Berdasarkan Problem

Tidak ada satu metrik yang selalu paling tepat untuk semua permasalahan.

Classification

Jika ingin mengetahui proporsi prediksi yang benar secara keseluruhan:

Accuracy

Jika biaya False Positive penting:

Precision

Jika biaya False Negative penting:

Recall

Jika ingin melihat keseimbangan precision dan recall:

F1-score

Pemilihan metrik tetap harus mempertimbangkan karakteristik dataset dan tujuan aplikasi.

Regression

Jika ingin mengukur proporsi variasi target yang dijelaskan model:

R²

Jika ingin mengetahui rata-rata besar absolute error dalam satuan target:

MAE

Jika ingin memberikan penalti lebih besar terhadap error yang besar:

MSE

Jika ingin penalti seperti MSE tetapi hasil kembali ke satuan target:

RMSE

Perbedaan Tiga Cara Evaluasi Scikit-Learn

Dalam workflow Machine Learning, kita sekarang telah mempelajari tiga pendekatan evaluasi.

1. `.score()`

Menggunakan metode bawaan estimator.

Contoh:

model.score(X_test, y_test)

Metrik yang digunakan bergantung pada estimator.

2. `scoring` pada Cross-Validation

Digunakan bersama fungsi seperti:

cross_val_score()

Contoh:

cross_val_score(
    model,
    X,
    y,
    cv=5,
    scoring="accuracy"
)

Pendekatan ini memungkinkan kita menentukan metrik sekaligus melakukan cross-validation.

3. `sklearn.metrics`

Menggunakan fungsi metrik secara langsung.

Contoh:

y_preds = model.predict(X_test)

accuracy_score(y_test, y_preds)

Pendekatan ini sangat fleksibel karena kita dapat menghitung beberapa metrik berdasarkan prediksi yang sama.

Tabel Perbandingan

Pendekatan	Contoh	Fokus
`.score()`	`model.score()`	Scorer default estimator
`scoring`	`cross_val_score(..., scoring="f1")`	Evaluasi dengan cross-validation
`sklearn.metrics`	`f1_score(y_test, y_preds)`	Menghitung metrik secara langsung

Ketiganya dapat digunakan dalam workflow Machine Learning yang berbeda sesuai kebutuhan.

Penting: Evaluasi Harus Menggunakan Data yang Tepat

Pada evaluasi menggunakan test set, model seharusnya tidak dilatih menggunakan data test.

Workflow yang benar:

Dataset
   │
   ▼
Train/Test Split
   │
   ├── Training Data
   │       │
   │       ▼
   │     Model
   │       │
   │       ▼
   │
   └── Test Data
           │
           ▼
        Predict
           │
           ▼
         y_pred
           │
           ▼
     sklearn.metrics

Jangan melakukan:

model.fit(X_test, y_test)

kemudian menggunakan data yang sama untuk mengklaim performa pada test set.

Test set seharusnya digunakan untuk evaluasi terhadap data yang tidak digunakan dalam proses training model.

Kebiasaan Penting dalam Evaluasi Model

Selalu Bandingkan `y_true` dan `y_pred`

Sebagian besar fungsi metric menggunakan pola:

metric_function(
    y_true,
    y_pred
)

Contoh:

accuracy_score(y_test, y_preds)

atau:

mean_absolute_error(y_test, y_preds)

Gunakan Nama Variabel yang Jelas

Daripada:

a = model.predict(X_test)

lebih baik:

y_preds = model.predict(X_test)

Karena nama tersebut langsung menunjukkan bahwa variabel berisi hasil prediksi.

Gunakan Random State

Untuk eksperimen yang dapat direproduksi:

train_test_split(
    X,
    y,
    test_size=0.2,
    random_state=42
)

Dan untuk model yang memiliki randomization:

RandomForestClassifier(
    n_estimators=100,
    random_state=42
)

Dengan demikian, eksperimen lebih mudah diulang dan dibandingkan.

Membaca Dokumentasi `sklearn.metrics`

Scikit-Learn memiliki banyak fungsi evaluasi.

Ketika membutuhkan metrik tertentu, biasakan mencari dokumentasi resmi dan memahami:

Nama fungsi
Parameter
Return value
Cara interpretasi
Apakah metrik mendukung binary classification
Apakah mendukung multiclass
Apakah memerlukan parameter tambahan
Apakah nilai lebih tinggi atau lebih rendah yang lebih baik

Contoh pola pencarian fungsi:

from sklearn.metrics import nama_metric

Kemudian gunakan:

nama_metric(y_true, y_pred)

Namun tidak semua metric memiliki signature yang sama, sehingga dokumentasi tetap perlu diperiksa sebelum digunakan.

tip

Baca Dokumentasi: https://scikit-learn.org/stable/api/sklearn.metrics.html

Ringkasan

Pada materi ini kita mempelajari cara ketiga untuk melakukan evaluasi model Scikit-Learn, yaitu menggunakan fungsi-fungsi dari:

sklearn.metrics

Untuk classification, beberapa fungsi penting adalah:

accuracy_score()
precision_score()
recall_score()
f1_score()

Untuk regression:

r2_score()
mean_absolute_error()
mean_squared_error()

Pola dasarnya adalah:

y_preds = model.predict(X_test)

metric_function(
    y_test,
    y_preds
)

Cheat Sheet Classification

from sklearn.metrics import (
    accuracy_score,
    precision_score,
    recall_score,
    f1_score
)

y_preds = clf.predict(X_test)

accuracy = accuracy_score(y_test, y_preds)
precision = precision_score(y_test, y_preds)
recall = recall_score(y_test, y_preds)
f1 = f1_score(y_test, y_preds)

Cheat Sheet Regression

from sklearn.metrics import (
    r2_score,
    mean_absolute_error,
    mean_squared_error
)

y_preds = model.predict(X_test)

r2 = r2_score(y_test, y_preds)
mae = mean_absolute_error(y_test, y_preds)
mse = mean_squared_error(y_test, y_preds)

Jika membutuhkan RMSE:

import numpy as np

rmse = np.sqrt(mse)

Key Takeaways

Hal-hal penting yang perlu diingat:

sklearn.metrics menyediakan fungsi evaluasi yang dapat digunakan secara langsung.
Evaluasi dilakukan dengan membandingkan y_true dengan y_pred.
accuracy_score() digunakan untuk menghitung accuracy.
precision_score() digunakan untuk menghitung precision.
recall_score() digunakan untuk menghitung recall.
f1_score() digunakan untuk menghitung F1-score.
r2_score() digunakan untuk menghitung R².
mean_absolute_error() digunakan untuk menghitung MAE.
mean_squared_error() digunakan untuk menghitung MSE.
Single train/test split lebih sederhana dan cepat, tetapi hasilnya bergantung pada pembagian data.
Cross-validation mengevaluasi model pada beberapa fold sehingga memberikan beberapa hasil evaluasi.
Tidak ada satu metrik yang selalu paling tepat; pemilihan metrik harus disesuaikan dengan tujuan problem.
Dokumentasi Scikit-Learn merupakan referensi penting untuk mengetahui fungsi metric dan parameter yang tersedia.

Kesimpulan

Evaluasi model merupakan bagian penting dari workflow Machine Learning.

Setelah model menghasilkan prediksi:

y_preds = model.predict(X_test)

kita dapat menggunakan sklearn.metrics untuk mengetahui kualitas prediksi tersebut.

Untuk classification:

Accuracy
Precision
Recall
F1-score

Untuk regression:

R²
MAE
MSE
RMSE

Dengan memahami berbagai metrik tersebut, kita tidak hanya mengetahui apakah model menghasilkan prediksi, tetapi juga dapat memahami seberapa baik model bekerja dan dari sisi mana performanya perlu diperbaiki.

Pada tahap berikutnya, metrik-metrik ini akan menjadi dasar untuk membandingkan model, memilih model yang sesuai, dan melakukan optimasi terhadap performa Machine Learning.

Modul sklearn.metrics​

Konsep Dasar y_true dan y_pred​

y_true​

y_pred​

Classification Metrics​

accuracy_score()​

precision_score()​

recall_score()​

f1_score()​

Workflow Evaluasi Classification​

Contoh Lengkap Classification​

Regression Metrics​

r2_score()​

mean_absolute_error()​

mean_squared_error()​

RMSE dari MSE​

Workflow Evaluasi Regression​

Contoh Lengkap Regression​

Single Train/Test Split vs Cross-Validation​

Single Train/Test Split​

Cross-Validation​

Hubungan sklearn.metrics dengan Cross-Validation​

Kapan Menggunakan sklearn.metrics?​

Memilih Metrik Berdasarkan Problem​

Classification​

Regression​

Perbedaan Tiga Cara Evaluasi Scikit-Learn​

1. .score()​

2. scoring pada Cross-Validation​

3. sklearn.metrics​

Tabel Perbandingan​

Penting: Evaluasi Harus Menggunakan Data yang Tepat​

Kebiasaan Penting dalam Evaluasi Model​

Selalu Bandingkan y_true dan y_pred​

Gunakan Nama Variabel yang Jelas​

Gunakan Random State​

Membaca Dokumentasi sklearn.metrics​

Ringkasan​

Cheat Sheet Classification​

Cheat Sheet Regression​

Key Takeaways​

Kesimpulan​

Referensi​

Share

Modul `sklearn.metrics`

Konsep Dasar `y_true` dan `y_pred`

`y_true`

`y_pred`

Classification Metrics

`accuracy_score()`

`precision_score()`

`recall_score()`

`f1_score()`

Workflow Evaluasi Classification

Contoh Lengkap Classification

Regression Metrics

`r2_score()`

`mean_absolute_error()`

`mean_squared_error()`

RMSE dari MSE

Workflow Evaluasi Regression

Contoh Lengkap Regression

Single Train/Test Split vs Cross-Validation

Single Train/Test Split

Cross-Validation

Hubungan `sklearn.metrics` dengan Cross-Validation

Kapan Menggunakan `sklearn.metrics`?

Memilih Metrik Berdasarkan Problem

Classification

Regression

Perbedaan Tiga Cara Evaluasi Scikit-Learn

1. `.score()`

2. `scoring` pada Cross-Validation

3. `sklearn.metrics`

Tabel Perbandingan

Penting: Evaluasi Harus Menggunakan Data yang Tepat

Kebiasaan Penting dalam Evaluasi Model

Selalu Bandingkan `y_true` dan `y_pred`

Gunakan Nama Variabel yang Jelas

Gunakan Random State

Membaca Dokumentasi `sklearn.metrics`

Ringkasan

Cheat Sheet Classification

Cheat Sheet Regression

Key Takeaways

Kesimpulan

Referensi