Data Splitting

1. Apa Itu Data Splitting?

Data Splitting adalah proses membagi dataset menjadi beberapa bagian yang digunakan untuk melatih, menguji, dan mengevaluasi model machine learning. Tujuan utama dari data splitting adalah menghindari overfitting dan memastikan bahwa model yang dilatih dapat bekerja dengan baik pada data baru yang belum pernah dilihat sebelumnya.

Biasanya, dataset dibagi menjadi dua atau tiga bagian utama:

1. Training Set (Data Latih) Digunakan untuk melatih model.
2. Validation Set (Data Validasi) (Opsional) Digunakan untuk menyetel parameter model sebelum pengujian.
3. Test Set (Data Uji) Digunakan untuk mengevaluasi performa model pada data yang belum pernah dilihat.

 

2. Mengapa Data Splitting Penting?

       Menghindari Overfitting → Model yang dilatih tanpa data uji bisa terlalu spesifik pada data latih dan gagal bekerja dengan baik pada data baru.

       Evaluasi Performa Model yang Akurat → Dengan memisahkan data uji, kita dapat mengukur seberapa baik model menangani data yang belum pernah dilihat.

       Memastikan Model Dapat Diterapkan ke Dunia Nyata → Model harus mampu bekerja pada data baru, bukan hanya data yang sudah dipelajari selama training.

 

3. Cara Melakukan Data Splitting

a. Train-Test Split (Pembagian 80-20 atau 70-30)

Metode paling dasar adalah membagi dataset menjadi training dan testing.

• Training Set → Biasanya 70-80% dari dataset, digunakan untuk melatih model.
• Test Set → Sisanya 20-30%, digunakan untuk mengukur kinerja model setelah pelatihan.

Contoh Implementasi dalam Python:

from sklearn.model_selection import train_test_split

 

# Contoh data

X = [[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]] # Fitur

y = [0, 1, 0, 1, 0, 1, 0, 1, 0, 1] # Label

 

# Membagi data menjadi 80% training dan 20% testing

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

 

print("Training Data:", X_train)

print("Testing Data:", X_test)

Keuntungan: Mudah diterapkan dan cepat.
Kekurangan: Pembagian ini mungkin menyebabkan variasi data yang kurang optimal, terutama jika dataset kecil.

 

b. Train-Validation-Test Split (Pembagian 60-20-20 atau 70-15-15)

Metode ini lebih baik dibandingkan train-test split, karena menambahkan validation set untuk menyetel parameter model sebelum diuji pada test set.

• Training Set (60-70%) → Untuk melatih model.
• Validation Set (15-20%) → Untuk menyetel parameter model sebelum diuji pada test set.
• Test Set (15-20%) → Untuk evaluasi akhir model.

Contoh Implementasi dalam Python:

X_train, X_temp, y_train, y_temp = train_test_split(X, y, test_size=0.4, random_state=42)

X_val, X_test, y_val, y_test = train_test_split(X_temp, y_temp, test_size=0.5, random_state=42)

 

print("Training Data:", len(X_train))

print("Validation Data:", len(X_val))

print("Testing Data:", len(X_test))

Keuntungan: Lebih akurat karena model diuji pada validation set sebelum diuji di test set.
Kekurangan: Membutuhkan dataset yang lebih besar agar tidak kehilangan terlalu banyak data untuk training.

 

c. K-Fold Cross-Validation (Pembagian Data Secara Berulang)

K-Fold Cross-Validation adalah teknik pembagian data di mana dataset dibagi menjadi K bagian (folds), lalu model dilatih dan diuji beberapa kali dengan kombinasi data yang berbeda.

• Misalnya K=5, maka dataset dibagi menjadi 5 bagian.
• Model dilatih menggunakan 4 bagian dan diuji pada 1 bagian.
• Proses diulang 5 kali, dengan setiap bagian bergantian menjadi test set.
• Hasil akhir adalah rata-rata dari semua evaluasi.

Contoh Implementasi dalam Python:

from sklearn.model_selection import KFold

import numpy as np

 

X = np.array(range(1, 11))

y = np.array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1])

 

kf = KFold(n_splits=5, shuffle=True, random_state=42)

 

for train_index, test_index in kf.split(X):

print("Train:", X[train_index], "Test:", X[test_index])

Keuntungan: Semua data digunakan sebagai training dan testing, sehingga hasil lebih akurat.
Kekurangan: Proses lebih lambat karena model dilatih dan diuji beberapa kali.

 

4. Kesalahan Umum dalam Data Splitting & Cara Menghindarinya

4.1. Melakukan Oversampling Sebelum Membagi Data

• Masalah: Jika teknik oversampling (SMOTE, ADASYN, dll.) dilakukan sebelum data dibagi, maka sampel sintetis bisa masuk ke dalam test set, menyebabkan data leakage dan hasil evaluasi yang tidak realistis.
• Solusi: Lakukan oversampling hanya pada training set setelah pembagian data.

Salah:

X_resampled, y_resampled = SMOTE().fit_resample(X, y)

X_train, X_test, y_train, y_test = train_test_split(X_resampled, y_resampled, test_size=0.2)

Benar:

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

X_train_resampled, y_train_resampled = SMOTE().fit_resample(X_train, y_train)

 

4.2. Data Tidak Teracak dengan Baik (No Shuffling)

• Masalah: Jika dataset memiliki pola tertentu (misalnya semua data kelas "A" berada di awal, semua data kelas "B" di akhir), maka pembagian tanpa shuffling bisa menyebabkan distribusi yang tidak merata.
• Solusi: Gunakan shuffle=True dalam train_test_split.

Contoh Benar:

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

 

4.3. Menggunakan Data Testing untuk Hyperparameter Tuning

• Masalah: Jika kita menggunakan test set untuk menyetel parameter model, maka kita secara tidak langsung membuat model menghafal test set, yang menyebabkan overfitting.
• Solusi: Gunakan validation set untuk tuning, bukan test set.

 

5. Kesimpulan

5.1. Data Splitting sangat penting dalam machine learning untuk memastikan model dapat bekerja dengan baik pada data baru.
5.2. Gunakan metode yang sesuai dengan ukuran dataset:

• Train-Test Split (80-20) untuk kasus sederhana.
• Train-Validation-Test Split (60-20-20) untuk tuning parameter.
• K-Fold Cross-Validation jika ingin hasil lebih akurat.

Hindari kesalahan umum, seperti oversampling sebelum splitting, tidak melakukan shuffling, atau menggunakan test set untuk tuning.

 

 

 

Oversampling

Oversampling adalah teknik dalam pemrosesan data yang digunakan untuk menangani ketidakseimbangan kelas (imbalanced data) dalam dataset klasifikasi. Teknik ini bekerja dengan meningkatkan jumlah sampel dari kelas minoritas, sehingga distribusi data menjadi lebih seimbang, membantu model machine learning agar tidak terlalu bias terhadap kelas mayoritas.

Ketidakseimbangan data terjadi ketika jumlah sampel dalam satu kelas jauh lebih banyak dibandingkan dengan kelas lainnya, yang dapat menyebabkan model cenderung mengabaikan kelas dengan jumlah data lebih sedikit.

 

Contoh Ketidakseimbangan Data:

Kelas	Jumlah Sampel
Negatif	900
Positif	100

Dalam kasus ini, model yang dilatih tanpa oversampling kemungkinan akan lebih sering cenderung memprediksi negatif, karena kelas negatif lebih dominan dalam dataset.

 

2. Jenis-Jenis Oversampling

Ada beberapa metode oversampling yang sering digunakan, di antaranya:

a. Random Oversampling (ROS)

• Teknik paling sederhana, yaitu menyalin sampel dari kelas minoritas secara acak hingga jumlahnya sama dengan kelas mayoritas.
• Kelebihan: Mudah diterapkan, meningkatkan keseimbangan data.
• Kekurangan: Dapat menyebabkan overfitting karena model melihat sampel yang sama berulang kali.

 

Contoh Implementasi dalam Python:

from imblearn.over_sampling import RandomOverSampler

X_resampled, y_resampled = RandomOverSampler().fit_resample(X, y)

 

b. Synthetic Minority Over-sampling Technique (SMOTE)

• SMOTE tidak hanya menyalin data lama, tetapi membuat sampel baru dengan melakukan interpolasi dari data yang ada.
• Cara kerjanya:
1. Memilih titik data minoritas secara acak.
2. Mencari k-tetangga terdekat (k-NN).
3. Membuat sampel sintetis di antara dua titik terdekat.
• Kelebihan: Mengurangi risiko overfitting dibandingkan Random Oversampling.
• Kekurangan: Bisa menghasilkan data sintetis yang tidak sepenuhnya representatif dari data asli.

 

Contoh Implementasi dalam Python:

from imblearn.over_sampling import SMOTE

X_resampled, y_resampled = SMOTE().fit_resample(X, y)

 

c. Adaptive Synthetic Sampling (ADASYN)

• Variasi dari SMOTE, tetapi lebih fokus pada area yang lebih sulit diklasifikasikan.
• ADASYN lebih banyak menghasilkan sampel sintetis di area yang lebih kompleks dan sulit dipelajari oleh model.
• Kelebihan: Meningkatkan akurasi pada daerah keputusan yang sulit.
• Kekurangan: Bisa menyebabkan noise pada dataset jika diterapkan secara agresif.

 

Contoh Implementasi dalam Python:

from imblearn.over_sampling import ADASYN

X_resampled, y_resampled = ADASYN().fit_resample(X, y)

 

3. Perbandingan Metode Oversampling

Metode	Cara Kerja	Keuntungan	Kelemahan
Random Oversampling	Menyalin sampel dari kelas minoritas	Mudah diterapkan	Risiko overfitting
SMOTE	Membuat sampel sintetis berdasarkan interpolasi data	Mengurangi overfitting	Bisa menghasilkan data yang tidak representatif
ADASYN	Membuat lebih banyak sampel sintetis di area yang sulit diklasifikasikan	Lebih adaptif terhadap kompleksitas data	Bisa menambahkan noise jika terlalu agresif

---

4. Kapan Menggunakan Oversampling?

Oversampling digunakan ketika:

  Dataset sangat tidak seimbang, misalnya satu kelas hanya memiliki 5-10% dari total data.

  Model machine learning mengalami bias terhadap kelas mayoritas.

  Precision, recall, atau F1-score kelas minoritas terlalu rendah.

Namun, jangan gunakan oversampling jika:

       Dataset sudah cukup seimbang.

       Terdapat risiko overfitting yang tinggi.

 

5. Kesalahan Umum dalam Oversampling

1. Melakukan Oversampling Sebelum Membagi Data Training & Testing
• Kesalahan: Oversampling dilakukan sebelum data dibagi, sehingga data sintetis juga masuk ke dalam testing set → data leakage!
• Solusi: Lakukan oversampling hanya pada data training setelah membagi data.

Salah:

X_resampled, y_resampled = SMOTE().fit_resample(X, y)

X_train, X_test, y_train, y_test = train_test_split(X_resampled, y_resampled, test_size=0.2)

Benar:

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

X_train_resampled, y_train_resampled = SMOTE().fit_resample(X_train, y_train)

2. Menggunakan Oversampling pada Semua Fitur Secara Naif
• Jangan gunakan oversampling pada fitur yang tidak perlu, seperti ID pengguna atau variabel kategori tanpa preprocessing.
3. Mengabaikan Evaluasi Model Setelah Oversampling
• Setelah menggunakan oversampling, evaluasi kembali model dengan metrik seperti Precision, Recall, dan F1-Score, bukan hanya akurasi.

 

6. Studi Kasus: Pengaruh Oversampling pada Model Machine Learning

Tanpa Oversampling:

• Accuracy: 90%
• Precision Positif: 30%
• Recall Positif: 10%

Dengan SMOTE:

• Accuracy: 85%
• Precision Positif: 80%
• Recall Positif: 75%

Dengan oversampling, model lebih seimbang dalam mengenali kelas minoritas meskipun akurasi total sedikit turun.

---

7. Kesimpulan

  Oversampling adalah teknik penting dalam mengatasi ketidakseimbangan data, terutama dalam klasifikasi machine learning.

  Metode seperti SMOTE dan ADASYN lebih efektif dibandingkan Random Oversampling karena mengurangi risiko overfitting.

  Pastikan oversampling hanya dilakukan pada data training untuk menghindari data leakage.

  Evaluasi model setelah oversampling menggunakan F1-score, Precision, dan Recall, bukan hanya akurasi.

Dengan menerapkan oversampling yang benar, model machine learning dapat lebih akurat dan adil dalam mengenali kelas minoritas.

 

Annotator

Annotator adalah seseorang atau sistem yang memberikan label atau anotasi pada data untuk keperluan analisis, pelatihan model machine learning, atau penelitian. Anotasi ini dapat berupa label kategori, tagging teks, bounding box dalam gambar, atau segmentasi suara tergantung pada jenis data yang digunakan.

---

Jenis-Jenis Annotator

1. Annotator Manual (Manusia)
• Individu yang secara langsung memberi label pada data berdasarkan pemahaman mereka.
• Digunakan dalam tugas seperti analisis sentimen, anotasi teks medis, dan labeling gambar.
• Contoh: Annotator menandai komentar sebagai positif, negatif, atau netral dalam analisis sentimen.
2. Annotator Otomatis (Sistem AI)
• Model machine learning yang dilatih untuk memberikan label secara otomatis.
• Contoh: Google Translate menandai jenis bahasa dalam teks, atau sistem OCR (Optical Character Recognition) mengidentifikasi teks dari gambar.
3. Annotator Hybrid (Manusia + AI)
• Kombinasi antara manusia dan sistem otomatis untuk meningkatkan efisiensi dan akurasi.
• Contoh: Manusia memverifikasi label yang diberikan oleh AI dalam dataset analisis sentimen.

---

Peran Annotator dalam Machine Learning & NLP

• Membantu pelatihan model AI → Memberikan label pada data sehingga model bisa belajar pola dari dataset yang terstruktur.
• Meningkatkan kualitas dataset → Anotasi yang baik menghasilkan dataset yang lebih akurat dan dapat diandalkan.
• Validasi data → Digunakan untuk mengevaluasi keakuratan model dengan membandingkan prediksi model dengan label yang diberikan oleh annotator manusia.

---

Contoh Anotasi dalam Berbagai Bidang

Bidang	Contoh Anotasi
Analisis Sentimen	Label komentar sebagai positif, negatif, atau netral.
Computer Vision	Bounding box pada objek dalam gambar.
Speech Recognition	Transkripsi teks dari audio.
Medis	Label penyakit berdasarkan laporan medis.

---

Masalah dalam Anotasi Data

1. Subjektivitas → Anotator yang berbeda bisa memberi label yang berbeda untuk data yang sama.
2. Ketidaksepakatan Annotator → Bisa diukur dengan Cohen's Kappa atau Fleiss Kappa untuk menilai konsistensi antar-annotator.
3. Biaya & Waktu → Anotasi manual memerlukan waktu dan tenaga yang besar, sehingga sering digunakan AI untuk membantu proses ini.

---

Annotator memainkan peran kunci dalam berbagai aplikasi machine learning dan pemrosesan data. Mereka membantu memastikan bahwa dataset memiliki kualitas tinggi, yang berkontribusi pada akurasi dan kinerja model AI.

 

Rentang nilai Cohen

Rentang nilai pada Cohen s Kappa berasal dari penelitian dan literatur akademik yang telah menetapkan standar interpretasi untuk tingkat kesepakatan antar-annotator. Salah satu referensi utama adalah Landis & Koch (1977), yang mengusulkan kategori interpretasi berikut:

 

Nilai Kappa	Tingkat Kesepakatan
< 0.00	Poor (Sangat Buruk)
0.00 - 0.20	Slight (Sangat Rendah)
0.21 - 0.40	Fair (Rendah)
0.41 - 0.60	Moderate (Sedang)
0.61 - 0.80	Substantial (Baik)
0.81 - 1.00	Almost Perfect (Sangat Baik)

 

Referensi Akademik

1. Landis, J. R., & Koch, G. G. (1977). The Measurement of Observer Agreement for Categorical Data. Biometrics, 33(1), 159-174.
2. Fleiss, J. L. (1981). Statistical Methods for Rates and Proportions.
3. McHugh, M. L. (2012). Interrater reliability: The kappa statistic. Biochemia Medica, 22(3), 276-282.

 

Ada beberapa variasi rentang interpretasi yang digunakan dalam penelitian lain, seperti dari Fleiss (1981) dan Cicchetti (1994), tetapi rentang Landis & Koch adalah yang paling umum digunakan dalam NLP dan analisis sentimen.

 

 

 

 

 

Metrik Cohen

Cohen's Kappa adalah metrik statistik yang digunakan untuk mengukur kesepakatan antar-annotator dalam tugas klasifikasi atau pelabelan data, dengan mempertimbangkan kemungkinan kesepakatan yang terjadi secara acak.

Metrik ini sangat berguna dalam analisis sentimen, anotasi teks, diagnosis medis, dan penelitian sosial, di mana beberapa individu memberikan label terhadap data yang sama.

---

Rumus Cohen's Kappa

Cohen's Kappa (k) dihitung menggunakan rumus berikut:

K=(p₀-p_e)/(1-p_e)

Di mana:

P₀ (Observed Agreement) = Proporsi kesepakatan aktual antara annotator.

P_e (Expected Agreement) = Proporsi kesepakatan yang diharapkan berdasarkan probabilitas acak.

Nilai Cohen's Kappa berkisar antara -1 hingga 1:

1       → Kesepakatan sempurna antara annotator.

0       → Kesepakatan terjadi secara acak.

Negatif → Kesepakatan lebih buruk daripada tebakan acak (annotator sering tidak setuju).

 

Contoh Perhitungan Cohen's Kappa Secara Manual

Misalkan dua annotator mengevaluasi 100 komentar YouTube tentang kendaraan listrik, dengan hasil sebagai berikut:

Kategori Sentimen	Annotator 1	Annotator 2
Positif	40	35
Negatif	60	65

 

1. Hitung P₀ (Observed Agreement):
Annotator setuju dalam:

• 35 dari 40 komentar positif.
• 55 dari 60 komentar negatif.

 

Total kesepakatan: p=(35+55)/100 = 0.90

 

2. Hitung P_e (Expected Agreement):
Probabilitas annotator 1 dan 2 memberikan label yang sama dihitung sebagai:

 

P_e =(P_pos1 P_pos2) + (P_neg1 P_neg2 )

 

P_e = ((40/100) x (35/100)) + ((60/100) x (65/100))

 

P_e =(0.4 0.35)+(0.6 0.65)=0.14+0.39=0.53

 

3. Hitung Cohen's Kappa:

κ=(0.90−0.53)/(1−0.53)=(0.37)/(0.47)=0.79

 

Interpretasi Nilai Cohen's Kappa

Nilai Kappa	Tingkat Kesepakatan
0.81 - 1.00	Kesepakatan sangat baik
0.61 - 0.80	Kesepakatan baik
0.41 - 0.60	Kesepakatan sedang
0.21 - 0.40	Kesepakatan rendah
0.00 - 0.20	Kesepakatan sangat rendah (hampir acak)

Dari contoh di atas, Cohen's Kappa 0.79 menunjukkan bahwa annotator memiliki kesepakatan yang baik dalam pelabelan sentimen komentar.

 

Implementasi Cohen's Kappa dalam Python

Jika kita memiliki daftar label dari dua annotator, kita bisa menggunakan scikit-learn untuk menghitung Cohen's Kappa:

from sklearn.metrics import cohen_kappa_score

 

# Contoh data dari dua annotator (0 = Negatif, 1 = Positif)

annotator_1 = [1, 0, 1, 1, 0, 1, 0, 1, 0, 1]

annotator_2 = [1, 0, 1, 0, 0, 1, 0, 1, 1, 1]

 

# Menghitung Cohen's Kappa

kappa_score = cohen_kappa_score(annotator_1, annotator_2)

print(f"Cohen's Kappa Score: {kappa_score:.2f}")

Hasilnya akan memberikan nilai Kappa yang menunjukkan tingkat kesepakatan antara kedua annotator.

---

Kesimpulan

• Cohen's Kappa adalah metrik yang mengukur kesepakatan antar-annotator dengan mempertimbangkan kemungkinan kesepakatan acak.
• Metrik ini lebih akurat dibandingkan sekadar menghitung persentase kesepakatan.
• Nilai di atas 0.60 menunjukkan kesepakatan yang baik, sedangkan di bawah 0.20 menunjukkan kesepakatan rendah.
• Digunakan dalam analisis sentimen, anotasi teks, diagnosis medis, dan penelitian sosial untuk memastikan bahwa pelabelan dilakukan secara objektif dan dapat diandalkan.