Undersampling Acak dan Cluster Centroids
Peserta akan mengurangi sampel kelas mayoritas secara acak dan dengan ClusterCentroids, lalu membandingkan kehilangan informasi serta kinerja model yang dihasilkan.
Undersampling Acak dan Cluster Centroids adalah pelajaran Machine Learning Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Machine Learning Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Machine Learning Academy mencakup 4 pelajaran total.
Undersampling: Mengurangi Kelas Mayoritas
Jika oversampling memperbesar kelas minoritas, undersampling mengecilkan kelas mayoritas untuk menyeimbangkan dataset. Keuntungan utamanya: pelatihan menjadi lebih cepat karena jumlah data secara keseluruhan lebih sedikit. Risiko utamanya: Anda membuang informasi nyata dari kelas mayoritas, yang berpotensi menyebabkan model menghasilkan lebih banyak positif palsu. Undersampling paling berguna ketika kelas mayoritas sangat besar sehingga oversampling akan membuat pelatihan berjalan terlalu lambat.
Undersampling Acak: Menghapus Contoh Mayoritas Secara Acak
RandomUnderSampler memilih dan menghapus sampel kelas mayoritas secara acak hingga rasio yang diinginkan tercapai. Ini adalah metode undersampling tercepat, tetapi membuang informasi yang mungkin berguna. Pada dataset kecil, undersampling acak dapat membuat model jauh lebih buruk karena menghapus sampel mayoritas yang berada di dekat batas keputusan.
from imblearn.under_sampling import RandomUnderSampler
from sklearn.datasets import make_classification
import numpy as np
X, y = make_classification(n_samples=1000, weights=[0.95, 0.05],
n_features=10, random_state=42)
print('Before undersampling:', np.bincount(y))
rus = RandomUnderSampler(sampling_strategy=1.0, random_state=42)
X_res, y_res = rus.fit_resample(X, y)
print('After undersampling:', np.bincount(y_res))
print('New total samples:', len(y_res))Mengendalikan Strategi Sampling
Parameter sampling_strategy mengatur rasio akhir antara kelas minoritas dan mayoritas. Nilai 1.0 membuat keduanya seimbang; nilai 0.5 mempertahankan keunggulan kelas mayoritas sebesar 2:1. Untuk kumpulan data yang sangat besar, Anda mungkin menetapkan 0.1 untuk membuat rasio 10:1 — tetap lebih baik daripada rasio awal 100:1 sekaligus menjaga pelatihan tetap cepat. Pilih berdasarkan biaya bisnis dari positif palsu dibandingkan negatif palsu.
from imblearn.under_sampling import RandomUnderSampler
from sklearn.datasets import make_classification
import numpy as np
X, y = make_classification(n_samples=10000, weights=[0.99, 0.01], random_state=42)
print('Original:', np.bincount(y))
for ratio in [1.0, 0.5, 0.2]:
rus = RandomUnderSampler(sampling_strategy=ratio, random_state=0)
_, y_r = rus.fit_resample(X, y)
counts = np.bincount(y_r)
print(f'ratio={ratio}: {counts} ({counts[1]/counts[0]:.2f} min:maj)')Cluster Centroids: Pengurangan Sampel yang Cerdas
ClusterCentroids menerapkan pengelompokan K-Means pada kelas mayoritas dan mengganti setiap kelompok dengan sentroidnya. Alih-alih mempertahankan sampel mayoritas secara acak, metode ini menyimpan kumpulan yang ringkas dan representatif. Cara ini mempertahankan struktur keseluruhan kelas mayoritas dengan lebih baik daripada penghapusan acak, tetapi lebih lambat dan memerlukan penyesuaian jumlah kelompok (yang sama dengan jumlah target kelas mayoritas setelah pengambilan sampel ulang).
from imblearn.under_sampling import ClusterCentroids
from sklearn.datasets import make_classification
import numpy as np
X, y = make_classification(n_samples=1000, weights=[0.9, 0.1],
n_features=5, random_state=42)
print('Before:', np.bincount(y))
cc = ClusterCentroids(sampling_strategy=1.0, random_state=42)
X_cc, y_cc = cc.fit_resample(X, y)
print('After ClusterCentroids:', np.bincount(y_cc))
print('Note: synthetic centroids replace real majority samples')Membandingkan Metode Pengurangan Sampel
Mari kita ukur kinerja pengurangan sampel acak, sentroid kelompok, dan tanpa pengambilan sampel ulang pada kumpulan data tidak seimbang yang sama, dengan skor F1 pada kelas minoritas sebagai metrik evaluasi.
from imblearn.under_sampling import RandomUnderSampler, ClusterCentroids
from imblearn.pipeline import Pipeline as ImbPipeline
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import f1_score
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
import numpy as np
X, y = make_classification(n_samples=1000, weights=[0.95, 0.05], random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=42)
sc = StandardScaler()
X_tr = sc.fit_transform(X_train)
X_te = sc.transform(X_test)
for name, sampler in [('None', None),
('RUS', RandomUnderSampler(random_state=0)),
('ClusterCentroids', ClusterCentroids(random_state=0))]:
if sampler:
Xr, yr = sampler.fit_resample(X_tr, y_train)
else:
Xr, yr = X_tr, y_train
lr = LogisticRegression().fit(Xr, yr)
f1 = f1_score(y_test, lr.predict(X_te))
print(f'{name:20s}: F1={f1:.4f} n_train={len(yr)}')Kehilangan Informasi dalam Pengurangan Sampel
Kelemahan utama pengurangan sampel adalah kehilangan informasi. Ketika 95 dari setiap 100 sampel kelas mayoritas dibuang, model melihat distribusi pelatihan yang sangat berbeda dari kenyataan. Hal ini dapat meningkatkan tingkat positif palsu dalam penggunaan produksi. Oleh karena itu, pengurangan sampel sering digabungkan dengan penambahan sampel (misalnya menggunakan SMOTEENN atau SMOTETomek) untuk menyeimbangkan kumpulan data sekaligus meminimalkan kehilangan informasi.
Menggabungkan Penambahan dan Pengurangan Sampel
SMOTETomek menggabungkan SMOTE (menambah sampel minoritas) dengan penghapusan Tautan Tomek (membersihkan sampel mayoritas ambigu di batas). Hasilnya menyeimbangkan kedua kelas dan menghapus sampel mayoritas di sekitar batas yang membingungkan pengklasifikasi. Pendekatan gabungan ini sering menghasilkan kinerja yang lebih baik daripada hanya menggunakan penambahan atau pengurangan sampel.
from imblearn.combine import SMOTETomek
from sklearn.datasets import make_classification
import numpy as np
X, y = make_classification(n_samples=1000, weights=[0.95, 0.05], random_state=42)
print('Before:', np.bincount(y))
st = SMOTETomek(random_state=42)
X_res, y_res = st.fit_resample(X, y)
print('After SMOTETomek:', np.bincount(y_res))Near Miss: Pengurangan Sampel Berdasarkan Jarak
NearMiss memilih sampel kelas mayoritas berdasarkan jaraknya dari sampel minoritas — dengan memilih yang terdekat (NearMiss-1) atau yang terjauh (NearMiss-3). Berbeda dari pengurangan sampel acak, NearMiss mempertahankan sampel mayoritas yang paling relevan untuk menentukan batas keputusan. NearMiss-3 mempertahankan sampel mayoritas yang paling jauh dari semua sampel minoritas sehingga menciptakan wilayah batas yang lebih bersih.
from imblearn.under_sampling import NearMiss
from sklearn.datasets import make_classification
import numpy as np
X, y = make_classification(n_samples=1000, weights=[0.9, 0.1], random_state=42)
print('Before:', np.bincount(y))
for version in [1, 2, 3]:
nm = NearMiss(version=version)
_, y_nm = nm.fit_resample(X, y)
print(f'NearMiss-{version}:', np.bincount(y_nm))Pengurangan Sampel di Dalam Pipeline imblearn
Seperti penambahan sampel, pengurangan sampel harus dilakukan di dalam pipeline untuk mencegah kebocoran selama validasi silang. Gunakan imblearn.pipeline.Pipeline dengan pengurang sampel sebagai langkah sebelum pengklasifikasi. fit_resample milik pengambil sampel dipanggil pada setiap lipatan pelatihan, dan lipatan pengujian tidak pernah diubah.
from imblearn.pipeline import Pipeline as ImbPipeline
from imblearn.under_sampling import RandomUnderSampler
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score
from sklearn.datasets import make_classification
import numpy as np
X, y = make_classification(n_samples=1000, weights=[0.95, 0.05], random_state=42)
pipe = ImbPipeline([
('sc', StandardScaler()),
('rus', RandomUnderSampler(random_state=42)),
('lr', LogisticRegression())
])
scores = cross_val_score(pipe, X, y, cv=5, scoring='f1')
print(f'CV F1 (RUS): {np.mean(scores):.4f} +/- {np.std(scores):.4f}')Kapan Memilih Pengurangan Sampel daripada Penambahan Sampel
Pilih pengurangan sampel ketika: kelas mayoritas sangat besar (jutaan sampel), waktu pelatihan menjadi hambatan, atau sumber daya komputasi terbatas. Pilih penambahan sampel (SMOTE) ketika: kelas minoritas sangat kecil (kurang dari beberapa ratus sampel), membuang data mayoritas akan membuat kumpulan pelatihan terlalu kecil, atau kelas minoritas memiliki struktur kompleks dan non-konveks yang dapat diisi oleh SMOTE. Dalam praktiknya, cobalah keduanya lalu bandingkan berdasarkan metrik validasi.
Mengevaluasi Setelah Pengurangan Sampel
Setelah pengambilan sampel ulang, selalu lakukan evaluasi pada kumpulan pengujian tidak seimbang asli — jangan pernah pada kumpulan pengujian yang telah diambil sampel ulang. Pengambilan sampel ulang pada data pengujian akan memberikan gambaran kinerja produksi yang tidak realistis. Tujuannya adalah meningkatkan perilaku model pada distribusi data yang sebenarnya, bukan mengoptimalkannya untuk distribusi seimbang buatan.
from sklearn.metrics import classification_report
from imblearn.under_sampling import RandomUnderSampler
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(n_samples=1000, weights=[0.95, 0.05], random_state=42)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.2, stratify=y, random_state=42)
sc = StandardScaler()
X_train_s = sc.fit_transform(X_train)
X_test_s = sc.transform(X_test)
rus = RandomUnderSampler(random_state=0)
X_r, y_r = rus.fit_resample(X_train_s, y_train)
lr = LogisticRegression().fit(X_r, y_r)
# Evaluate on ORIGINAL imbalanced test set
print(classification_report(y_test, lr.predict(X_test_s)))Pemeriksaan Singkat
Uji pemahaman Anda tentang pengurangan sampel dan Cluster Centroids dari pelajaran ini.
Ringkasan Pelajaran
Dalam pelajaran ini Anda mempelajari: RandomUnderSampler menghapus sampel mayoritas secara acak — cepat, tetapi berisiko kehilangan informasi penting pada batas; ClusterCentroids mengganti kelompok mayoritas dengan sentroidnya untuk mempertahankan distribusi kelas dengan lebih baik; dan selalu lakukan evaluasi pada kumpulan pengujian tidak seimbang asli untuk mengukur perilaku model di dunia nyata. Selanjutnya kita akan membahas pembobotan kelas dan penggeseran ambang sebagai alternatif pengambilan sampel ulang.
Belajar Python dengan tutor AI — gratis
Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.
- Kursus
- 30
- Pelajaran
- 120
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Undersampling Acak dan Cluster Centroids” gratis?
Ya — teks lengkap “Undersampling Acak dan Cluster Centroids” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Machine Learning Academy, upgrade ke CoddyKit PRO. Kursus Machine Learning Academy mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Undersampling Acak dan Cluster Centroids”?
Peserta akan mengurangi sampel kelas mayoritas secara acak dan dengan ClusterCentroids, lalu membandingkan kehilangan informasi serta kinerja model yang dihasilkan. Kamu berlatih Machine Learning Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai Machine Learning Academy?
Tidak diperlukan pengalaman sebelumnya. Machine Learning Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.
Berapa lama pelajaran “Undersampling Acak dan Cluster Centroids” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran Machine Learning Academy ini?
Ya. Setiap pelajaran Machine Learning Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Mendeteksi Ketidakseimbangan: Distribusi Kelas dan Jebakan Baseline
- Oversampling Acak dan SMOTE
- Undersampling Acak dan Cluster Centroids
- Bobot Kelas dan Penggeseran Ambang