Data Mining - Data Preprocessing: Mengatasi Outlier dan Normalisasi Data Menggunakan Python

Diposting oleh Sketzhbook April 02, 2026 Posting Komentar

Dalam dunia Machine Learning dan Data Science, ada sebuah pepatah terkenal: "Garbage In, Garbage Out". Artinya, seberapa pun canggihnya algoritma yang Anda gunakan, jika data yang dimasukkan berantakan (sampah), maka hasil prediksinya pun tidak akan akurat (sampah).

Dua masalah paling umum yang sering ditemui pada data mentah adalah adanya Outlier (Pencilan) dan perbedaan skala antar fitur yang terlalu jauh.

Pada artikel ini, kita akan membahas cara mendeteksi outlier, melihat dampaknya, membuangnya, dan melakukan normalisasi data menggunakan Python (Pandas, Seaborn, dan Scikit-Learn).

💡 Tips Sebelum Memulai: Tutorial ini dirancang sangat interaktif. Agar pengalaman belajar lebih maksimal, sangat disarankan untuk membuka Jupyter Notebook di komputer Anda atau membuat notebook baru di Google Colab secara gratis. Copy-paste kode di bawah ini sel demi sel (cell-by-cell) dan jalankan (Run) untuk melihat hasilnya secara langsung!

1. Apa itu Outlier?

Outlier adalah titik data yang nilainya menyimpang sangat jauh dari mayoritas data lainnya. Penyebabnya bisa bermacam-macam: kesalahan ketik saat data entry, error pada sensor, atau memang kejadian langka yang nyata.

Mari kita buat sebuah dataset simulasi berisi data Umur dan Gaji dari 10 karyawan. Perhatikan data milik Hadi; umurnya 150 tahun dan gajinya 150 juta. Ini adalah contoh outlier yang sangat ekstrem.

Ketikkan kode berikut di cell pertama Jupyter Notebook atau Google Colab Anda:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

sns.set_theme(style="whitegrid")

# Membuat dataset karyawan
data_karyawan = {
    'Nama': ['Andi', 'Budi', 'Citra', 'Dani', 'Eka', 'Fani', 'Gita', 'Hadi', 'Iwan', 'Joko'],
    'Umur': [22, 24, 23, 21, 25, 22, 24, 150, 23, 21], 
    'Gaji': [5000000, 5500000, 6000000, 4500000, 7000000, 5200000, 5800000, 150000000, 6200000, 4800000]
}
df = pd.DataFrame(data_karyawan)
display(df)

Visualisasi: Melihat Outlier dengan Mata Telanjang

Sebelum membersihkan data, sangat disarankan untuk melakukan visualisasi. Dua grafik yang paling ampuh untuk mendeteksi outlier adalah Boxplot dan Scatterplot.

[Image of Boxplot explaining quartiles and outliers]

Buat cell baru di notebook Anda dan jalankan kode visualisasi ini:

fig, axes = plt.subplots(1, 2, figsize=(12, 5))

# Boxplot Umur
sns.boxplot(x=df['Umur'], ax=axes[0], color='salmon')
axes[0].set_title('Boxplot Umur')

# Scatterplot Umur vs Gaji
sns.scatterplot(x=df['Umur'], y=df['Gaji'], ax=axes[1], color='red', s=100)
axes[1].set_title('Scatterplot (Umur vs Gaji)')
plt.show()

Jika Anda menjalankannya di Colab/Jupyter, Anda akan langsung melihat output grafik di mana ada satu titik merah yang "terbang" jauh sendirian. Itulah sang outlier.

2. Mengapa Outlier Berbahaya?

Bayangkan Anda sedang melatih model Regresi Linear untuk memprediksi Gaji berdasarkan Umur. Garis prediksi model Anda (yang seharusnya merepresentasikan tren mayoritas data) akan "tertarik" secara paksa ke arah outlier tersebut. Akibatnya, model Anda akan memberikan prediksi yang salah kaprah untuk karyawan normal lainnya. Membuang outlier (atau menanganinya secara khusus) adalah langkah krusial sebelum masuk ke tahap modeling.

3. Membersihkan Outlier dengan Metode IQR

Ada beberapa metode statistik untuk membuang outlier (seperti Z-Score atau pendekatan Mean/Standard Deviation). Namun, metode yang paling tangguh (robust) untuk outlier ekstrem adalah IQR (Interquartile Range).

Metode IQR bekerja dengan mencari nilai Kuartil 1 (25%) dan Kuartil 3 (75%), menghitung jarak keduanya (IQR), lalu menetapkan batas "pagar" bawah dan atas. Data di luar pagar ini akan dibuang.

Mari kita eksekusi pembersihannya di cell berikutnya:

# Hitung Q1, Q3, dan IQR untuk Umur
Q1 = df['Umur'].quantile(0.25)
Q3 = df['Umur'].quantile(0.75)
IQR = Q3 - Q1

# Tentukan batas bawah dan atas
batas_bawah_iqr = Q1 - 1.5 * IQR
batas_atas_iqr = Q3 + 1.5 * IQR

# Filter data: Ambil hanya data yang AMAN
df_clean = df[(df['Umur'] >= batas_bawah_iqr) & (df['Umur'] <= batas_atas_iqr)].copy()

print("Data Setelah Dibersihkan (Outlier Hadi terhapus):")
display(df_clean)

Sekarang, dataset kita sudah bersih dari data umur yang tidak masuk akal!

4. Normalisasi Data: Menyamakan Skala Fitur

Setelah data bersih, kita menghadapi masalah kedua: Skala.
Kolom Umur berada di angka puluhan (20-an), sedangkan kolom Gaji berada di angka jutaan.

Banyak algoritma Machine Learning (seperti K-Nearest Neighbors atau Neural Networks) sangat sensitif terhadap skala. Jika dibiarkan, model akan menganggap fitur Gaji jauh lebih penting daripada Umur semata-mata karena angkanya lebih besar. Solusinya? Normalisasi.

Kita akan membahas dua teknik yang paling populer dari library Scikit-Learn:

A. Min-Max Scaling

Min-Max Scaling memampatkan seluruh data ke dalam rentang 0 hingga 1. Nilai terkecil menjadi 0, dan nilai terbesar menjadi 1.

from sklearn.preprocessing import MinMaxScaler

fitur_numerik = df_clean[['Umur', 'Gaji']]
scaler_minmax = MinMaxScaler()

# Terapkan scaler
data_minmax = scaler_minmax.fit_transform(fitur_numerik)
df_minmax = pd.DataFrame(data_minmax, columns=['Umur_MinMax', 'Gaji_MinMax'])

print("Hasil Min-Max Scaling:")
display(df_minmax)

B. Standardization (Z-Score Normalization)

Standardization mengubah data sedemikian rupa sehingga rata-ratanya (Mean) menjadi 0 dan Standar Deviasinya menjadi 1. Metode ini sangat cocok untuk algoritma yang mengasumsikan data berdistribusi normal (seperti Regresi Linear atau SVM).

from sklearn.preprocessing import StandardScaler

scaler_std = StandardScaler()

# Terapkan scaler
data_standard = scaler_std.fit_transform(fitur_numerik)
df_standard = pd.DataFrame(data_standard, columns=['Umur_Std', 'Gaji_Std'])

print("Hasil Standardization:")
display(df_standard)

Kesimpulan

Melakukan data preprocessing mungkin tidak "seksi" seperti melatih model Deep Learning, tetapi tahapan ini memakan 80% waktu seorang Data Scientist karena di sinilah fondasi kualitas model dibangun.

Dengan memvisualisasikan data, mendeteksi dan membuang outlier menggunakan IQR, serta menormalkan skala fitur menggunakan Min-Max atau Standardization, Anda telah memastikan algoritma Anda belajar dari data yang sehat, masuk akal, dan proporsional.

Buka Google Colab atau Jupyter Notebook Anda sekarang, dan selamat mencoba bereksperimen dengan dataset Anda sendiri!

Download Materi

SKETZHBOOK