Tutorial 21 mnt baca

Panduan Lengkap Automated EDA dengan Python: ydata-profiling, Sweetviz, DataPrep, dan AutoViz

Pelajari cara mengotomatisasi EDA dengan empat library Python terbaik: ydata-profiling, Sweetviz, DataPrep.EDA, dan AutoViz. Panduan lengkap dengan contoh kode, perbandingan fitur, dan tips integrasi alur kerja ML.

Editorial Team

Pendahuluan: Apa Itu EDA dan Kenapa Harus Diotomatisasi?

Kalau kamu pernah terjun ke proyek data science atau machine learning, pasti sudah nggak asing dengan yang namanya Exploratory Data Analysis — atau biasa disingkat EDA. Konsep ini pertama kali diperkenalkan oleh John Tukey di tahun 1977, dan intinya sederhana: investigasi awal terhadap data untuk menemukan pola, anomali, menguji hipotesis, dan memeriksa asumsi lewat ringkasan statistik serta visualisasi. Tanpa EDA yang memadai, kamu ibarat berlayar tanpa kompas.

Dalam praktiknya, EDA itu mencakup banyak hal — mulai dari memeriksa distribusi variabel, mengidentifikasi missing values, mendeteksi outlier, sampai memahami korelasi antar fitur. Dan jujur saja, kalau semua ini dilakukan manual, bisa makan waktu berjam-jam. Bahkan berhari-hari, terutama kalau dataset-nya punya puluhan sampai ratusan kolom.

Nah, di sinilah automated EDA jadi penyelamat.

Dengan library Python yang dirancang khusus, seluruh proses EDA bisa dilakukan cuma dalam beberapa baris kode. Library-library ini otomatis menghasilkan laporan statistik yang komprehensif, visualisasi interaktif, dan insight yang actionable — semua dalam hitungan detik sampai menit. Tentu saja, otomatisasi ini bukan untuk menggantikan pemahaman mendalam kamu terhadap data. Tujuannya lebih ke mempercepat fase eksplorasi awal supaya kamu bisa lebih cepat fokus ke tahapan yang butuh pemikiran kritis dan domain expertise.

Beberapa alasan kenapa otomatisasi EDA makin penting di 2026:

  • Efisiensi waktu: Nggak perlu lagi menulis kode visualisasi dan statistik deskriptif berulang kali.
  • Konsistensi: Laporan yang terstandarisasi dan bisa direproduksi untuk setiap dataset baru.
  • Kelengkapan: Menjamin nggak ada aspek penting dari data yang kelewat di analisis awal.
  • Kolaborasi: Laporan HTML yang dihasilkan gampang dibagikan ke tim dan stakeholder non-teknis.
  • Onboarding lebih cepat: Anggota tim baru bisa langsung paham karakteristik dataset yang sedang dikerjakan.

Lanskap Tools Automated EDA di Ekosistem Python (2026)

Ekosistem Python punya banyak library untuk automated EDA yang sudah matang dan terus berkembang. Di tahun 2026, ada empat library utama yang mendominasi: ydata-profiling (penerus pandas-profiling), Sweetviz, DataPrep.EDA, dan AutoViz. Masing-masing punya filosofi desain, keunggulan, dan use case yang berbeda-beda.

Secara garis besar, keempat tools ini bisa dikategorikan berdasarkan pendekatan utamanya:

  • Report-based: ydata-profiling dan Sweetviz menghasilkan laporan HTML yang komprehensif dan self-contained.
  • Function-based: DataPrep.EDA menyediakan fungsi-fungsi modular yang bisa dipanggil sesuai kebutuhan.
  • Visualization-focused: AutoViz fokus ke pembuatan visualisasi otomatis dengan konfigurasi minimal.

Pemilihan tool yang tepat tergantung beberapa faktor — ukuran dataset, kebutuhan spesifik analisis, preferensi output, dan lingkungan kerja (Jupyter Notebook, script, atau pipeline). Di bagian-bagian selanjutnya, kita akan bahas satu per satu secara mendalam, lengkap dengan contoh kode praktis.

ydata-profiling: Solusi Profiling Data Paling Komprehensif

Sejarah dan Evolusi

Kalau kamu pernah pakai pandas-profiling, maka ydata-profiling adalah penerusnya. Pada tahun 2023, proyek ini mengalami rebranding di bawah naungan YData, dengan nama paket resmi berubah jadi ydata-profiling. Perubahan ini membawa sejumlah peningkatan signifikan — termasuk dukungan untuk Spark DataFrames, performa yang lebih baik, dan fitur-fitur baru yang nggak tersedia di versi lama.

Per 2026, versi terbarunya adalah 4.16.1, yang mensyaratkan Python >=3.10 dan <3.14. Library ini mendukung dua jenis DataFrame: Pandas DataFrame untuk dataset kecil sampai menengah, dan Spark DataFrame untuk dataset besar yang butuh pemrosesan terdistribusi.

Instalasi

Instalasinya cukup straightforward:

# Instalasi dasar dengan pip
pip install ydata-profiling==4.16.1

# Instalasi dengan dukungan Spark
pip install ydata-profiling[spark]==4.16.1

# Instalasi menggunakan conda
conda install -c conda-forge ydata-profiling

Pastikan versi Python kamu memenuhi persyaratan (>=3.10 dan <3.14). Verifikasi instalasi dengan menjalankan:

import ydata_profiling
print(ydata_profiling.__version__)
# Output: 4.16.1

Penggunaan Dasar dengan Dataset Titanic

Oke, mari kita mulai dengan contoh klasik — dataset Titanic. Menurut saya, ini masih jadi dataset paling pas buat belajar karena punya campuran tipe data yang beragam:

import pandas as pd
from ydata_profiling import ProfileReport

# Memuat dataset Titanic
df = pd.read_csv("https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv")

# Membuat profil report
profile = ProfileReport(
    df,
    title="Laporan Profiling Dataset Titanic",
    explorative=True
)

# Menyimpan sebagai file HTML
profile.to_file("titanic_profiling_report.html")

# Menampilkan di Jupyter Notebook
profile.to_notebook_iframe()

Kode di atas bakal menghasilkan laporan HTML yang sangat detail. Isinya mencakup:

  • Overview: Jumlah variabel, observasi, missing cells, duplicate rows, dan ukuran memori.
  • Variables: Analisis mendalam tiap kolom — distribusi, statistik deskriptif, nilai ekstrem, histogram.
  • Interactions: Scatter plot interaktif untuk melihat hubungan antar variabel numerik.
  • Correlations: Matriks korelasi dengan berbagai metode (Pearson, Spearman, Kendall, Phik, Cramér's V).
  • Missing Values: Visualisasi pola missing values pakai bar chart, matrix, dan heatmap.
  • Sample: Contoh data dari awal dan akhir dataset.
  • Duplicate Rows: Identifikasi dan penghitungan baris duplikat.

Honestly, pertama kali saya lihat laporan yang dihasilkan ydata-profiling, saya cukup terkesan. Lengkap banget.

Konfigurasi Lanjutan

ydata-profiling punya opsi konfigurasi yang sangat fleksibel. Kamu bisa menyesuaikan laporan sesuai kebutuhan:

from ydata_profiling import ProfileReport

# Konfigurasi untuk dataset besar (mode minimal)
profile_minimal = ProfileReport(
    df,
    title="Laporan Minimal Titanic",
    minimal=True,  # Mode minimal untuk dataset besar
    progress_bar=True
)

# Konfigurasi kustom yang lebih detail
profile_custom = ProfileReport(
    df,
    title="Laporan Kustom Titanic",
    explorative=True,
    correlations={
        "pearson": {"calculate": True},
        "spearman": {"calculate": True},
        "kendall": {"calculate": False},
        "phi_k": {"calculate": True},
        "cramers": {"calculate": True},
    },
    missing_diagrams={
        "bar": True,
        "matrix": True,
        "heatmap": True,
    },
    interactions={
        "continuous": True,
        "targets": ["Survived"]
    },
    vars={
        "num": {
            "quantiles": [0.05, 0.25, 0.5, 0.75, 0.95],
            "skewness_threshold": 20,
            "low_categorical_threshold": 5,
        },
        "cat": {
            "n_obs": 10,
        }
    }
)

profile_custom.to_file("titanic_custom_report.html")

Penggunaan dengan Spark DataFrame

Untuk dataset yang terlalu besar dan nggak muat di memori, ydata-profiling mendukung Spark DataFrame. Ini game changer buat kamu yang kerja dengan big data:

from pyspark.sql import SparkSession
from ydata_profiling import ProfileReport

# Inisialisasi Spark session
spark = SparkSession.builder \
    .appName("EDA dengan ydata-profiling") \
    .getOrCreate()

# Memuat data sebagai Spark DataFrame
spark_df = spark.read.csv("data_besar.csv", header=True, inferSchema=True)

# Membuat profil report dari Spark DataFrame
profile = ProfileReport(
    spark_df,
    title="Laporan Profiling Data Besar",
    explorative=True
)

profile.to_file("laporan_data_besar.html")

Perbandingan Dataset

Fitur yang menurut saya sangat berguna adalah kemampuan membandingkan dua dataset — misalnya data training dan testing:

from ydata_profiling import ProfileReport

# Misalkan kita punya data train dan test
train_df = pd.read_csv("train.csv")
test_df = pd.read_csv("test.csv")

# Membuat profil masing-masing
train_profile = ProfileReport(train_df, title="Data Training")
test_profile = ProfileReport(test_df, title="Data Testing")

# Membuat comparison report
comparison = train_profile.compare(test_profile)
comparison.to_file("comparison_report.html")

Sweetviz: Visualisasi Cantik untuk Perbandingan Dataset

Pengenalan Sweetviz

Sweetviz adalah library automated EDA yang punya fokus kuat pada visualisasi yang indah dan kemampuan perbandingan dataset. Library ini menghasilkan laporan HTML self-contained dengan visualisasi yang informatif sekaligus estetis. Cocok banget kalau kamu perlu membandingkan dataset (misalnya train vs test) atau menganalisis hubungan variabel terhadap target.

Catatan penting: Sweetviz saat ini punya masalah kompatibilitas dengan NumPy 2.0+. Kalau kamu pakai NumPy versi 2.0 ke atas, kemungkinan besar bakal ketemu error. Solusinya? Downgrade NumPy ke versi 1.x atau pakai virtual environment terpisah:

# Jika mengalami masalah kompatibilitas NumPy
pip install "numpy<2.0"
pip install sweetviz

Instalasi

# Instalasi Sweetviz
pip install sweetviz

# Atau dengan versi NumPy yang kompatibel
pip install sweetviz "numpy<2.0"

Penggunaan Dasar

Sweetviz menyediakan tiga fungsi utama untuk membuat laporan: analyze(), compare(), dan compare_intra(). Cukup intuitif.

import sweetviz as sv
import pandas as pd

# Memuat dataset Titanic
df = pd.read_csv("https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv")

# Analisis dasar
report = sv.analyze(
    source=df,
    target_feat="Survived",  # Variabel target
    pairwise_analysis="on"
)

# Menampilkan laporan di browser
report.show_html("sweetviz_titanic.html")

# Menampilkan di Jupyter Notebook
report.show_notebook()

Yang bikin Sweetviz istimewa adalah kemampuannya secara otomatis menampilkan asosiasi antara setiap fitur terhadap variabel target. Dalam contoh di atas, dengan menetapkan target_feat="Survived", Sweetviz langsung menunjukkan bagaimana tiap variabel berkorelasi dengan kolom Survived. Praktis banget.

Perbandingan Dataset

Ini dia fitur unggulan Sweetviz — perbandingan dataset yang sangat visual:

import sweetviz as sv
import pandas as pd

df = pd.read_csv("https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv")

# Membagi data menjadi train dan test
from sklearn.model_selection import train_test_split
train_df, test_df = train_test_split(df, test_size=0.2, random_state=42)

# Membandingkan dataset train vs test
comparison_report = sv.compare(
    source=[train_df, "Data Training"],
    compare=[test_df, "Data Testing"],
    target_feat="Survived"
)

comparison_report.show_html("sweetviz_comparison.html")

Perbandingan Intra-Dataset

Sweetviz juga bisa membandingkan segmen dalam satu dataset berdasarkan kondisi tertentu. Misalnya, membandingkan penumpang pria dan wanita:

import sweetviz as sv
import pandas as pd

df = pd.read_csv("https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv")

# Perbandingan intra-dataset: Pria vs Wanita
intra_report = sv.compare_intra(
    source_df=df,
    condition_series=df["Sex"] == "female",
    names=["Wanita", "Pria"],
    target_feat="Survived"
)

intra_report.show_html("sweetviz_gender_comparison.html")

Konfigurasi Fitur

Kamu juga bisa mengatur bagaimana Sweetviz memperlakukan kolom-kolom tertentu. Ini berguna kalau ada kolom yang mau di-skip atau dipaksa jadi tipe tertentu:

import sweetviz as sv
import pandas as pd

df = pd.read_csv("https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv")

# Konfigurasi fitur
feature_config = sv.FeatureConfig(
    skip=["PassengerId", "Name", "Ticket"],  # Kolom yang diabaikan
    force_num=["Pclass"],  # Paksa sebagai numerik
    force_cat=["Survived"],  # Paksa sebagai kategorikal
    force_text=["Cabin"]  # Paksa sebagai teks
)

report = sv.analyze(
    source=df,
    target_feat="Survived",
    feat_cfg=feature_config
)

report.show_html("sweetviz_configured.html")

DataPrep.EDA: Kecepatan dan Modularitas Terbaik

Pengenalan DataPrep

DataPrep itu beda dari yang lain. Kalau ydata-profiling dan Sweetviz menghasilkan satu laporan monolitik, DataPrep.EDA justru menawarkan pendekatan function-based yang modular. Kamu bisa panggil fungsi spesifik sesuai kebutuhan, tanpa harus nunggu seluruh laporan selesai diproses.

Keunggulan utamanya? Penggunaan Dask sebagai backend komputasi, yang memungkinkan kecepatan hingga 10 kali lebih cepat dibandingkan tools berbasis pandas murni. Buat yang sering kerja dengan dataset besar, ini jelas pilihan yang worth dipertimbangkan.

Instalasi

# Instalasi DataPrep
pip install dataprep

# Atau menggunakan conda
conda install -c conda-forge dataprep

Empat Fungsi Utama DataPrep.EDA

DataPrep.EDA punya empat fungsi utama, masing-masing dengan peran spesifik:

  1. plot(): Menghasilkan overview distribusi dan statistik untuk seluruh dataset atau kolom tertentu.
  2. plot_correlation(): Menampilkan analisis korelasi dengan berbagai metode.
  3. plot_missing(): Memvisualisasikan pola dan statistik missing values.
  4. plot_diff(): Membandingkan dua dataset secara visual.

Fungsi plot(): Overview Dataset

from dataprep.eda import plot
import pandas as pd

# Memuat dataset Titanic
df = pd.read_csv("https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv")

# Overview seluruh dataset
plot(df)

# Analisis satu kolom spesifik
plot(df, "Age")

# Analisis hubungan dua kolom
plot(df, "Age", "Survived")

# Dengan konfigurasi display
plot(df, display=["Stats", "Insights"])

Fungsi plot() ini fleksibel banget. Tanpa parameter kolom, dia kasih overview lengkap seluruh dataset. Kasih satu nama kolom, dia tampilkan analisis detail kolom itu. Kasih dua nama kolom, dia tampilkan hubungan antara keduanya. Simpel tapi powerful.

Fungsi plot_correlation(): Analisis Korelasi

from dataprep.eda import plot_correlation
import pandas as pd

df = pd.read_csv("https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv")

# Korelasi untuk semua kolom numerik
plot_correlation(df)

# Korelasi dengan metode spesifik
plot_correlation(df, value_range=[-1, 1])

# Korelasi untuk kolom tertentu terhadap yang lain
plot_correlation(df, "Survived")

# Korelasi antara dua kolom spesifik
plot_correlation(df, "Age", "Fare")

DataPrep mendukung berbagai metode korelasi termasuk Pearson, Spearman, dan Kendall Tau. Visualisasinya interaktif dan mudah dibaca — heatmap-nya jelas, dan korelasi yang signifikan langsung terlihat.

Fungsi plot_missing(): Analisis Missing Values

from dataprep.eda import plot_missing
import pandas as pd

df = pd.read_csv("https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv")

# Overview missing values seluruh dataset
plot_missing(df)

# Analisis missing values untuk kolom tertentu
plot_missing(df, "Age")

# Analisis impact missing values satu kolom terhadap kolom lain
plot_missing(df, "Age", "Survived")

Fungsi plot_missing() ini sangat membantu untuk memahami pola missing values. Dengan insight dari sini, kamu bisa memutuskan strategi imputasi yang tepat — apakah datanya hilang secara acak (MCAR), terkait variabel lain (MAR), atau hilang secara tidak acak (MNAR).

Fungsi plot_diff(): Perbandingan Dataset

from dataprep.eda import plot_diff
import pandas as pd
from sklearn.model_selection import train_test_split

df = pd.read_csv("https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv")

# Membagi dataset
train_df, test_df = train_test_split(df, test_size=0.2, random_state=42)

# Membandingkan distribusi train vs test
plot_diff([train_df, test_df], label=["Training", "Testing"])

Membuat Laporan Lengkap

Selain fungsi modular, DataPrep juga punya create_report() kalau kamu mau laporan HTML lengkap sekaligus:

from dataprep.eda import create_report
import pandas as pd

df = pd.read_csv("https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv")

# Membuat laporan lengkap
report = create_report(df, title="Laporan EDA Titanic - DataPrep")

# Menyimpan sebagai HTML
report.save("dataprep_titanic_report.html")

# Menampilkan di Jupyter Notebook
report.show()

AutoViz: Visualisasi Otomatis Satu Baris Kode

Pengenalan AutoViz

AutoViz mengambil pendekatan paling minimalis di antara keempat tools yang kita bahas. Filosofinya sederhana: visualisasikan dataset apapun, ukuran berapapun, cuma dengan satu baris kode. AutoViz otomatis menentukan jenis visualisasi yang paling tepat berdasarkan tipe data dan jumlah variabel.

Library ini cocok banget buat eksplorasi cepat — saat kamu baru terima dataset dan mau dapat gambaran visual tanpa mikir panjang soal chart apa yang harus dibuat. Kalau dataset-nya punya terlalu banyak kolom, AutoViz juga cukup pintar untuk memilih subset variabel yang paling informatif.

Instalasi

# Instalasi AutoViz
pip install autoviz

Penggunaan Dasar

Sesuai filosofinya, pakai AutoViz itu gampang banget:

from autoviz import AutoViz_Class

# Inisialisasi AutoViz
AV = AutoViz_Class()

# Visualisasi dari file CSV - satu baris kode!
df_viz = AV.AutoViz(
    filename="titanic.csv",
    sep=",",
    depVar="Survived",  # Variabel target (opsional)
    dfte=None,  # None jika menggunakan filename
    header=0,
    verbose=1,  # 0=minimal, 1=medium, 2=detailed
    lowess=False,
    chart_format="html",  # Format output: html, svg, png, bokeh, server
    max_rows_analyzed=150000,
    max_cols_analyzed=30
)

# Atau langsung dari DataFrame
import pandas as pd

df = pd.read_csv("https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv")

df_viz = AV.AutoViz(
    filename="",
    sep=",",
    depVar="Survived",
    dfte=df,
    header=0,
    verbose=1,
    chart_format="html"
)

Memahami Parameter AutoViz

Meskipun simpel, ada beberapa parameter yang perlu kamu pahami:

  • filename: Path ke file CSV. Pakai string kosong ("") kalau mau masukkan DataFrame langsung.
  • depVar: Nama variabel target. Pakai string kosong kalau nggak ada target.
  • dfte: Pandas DataFrame sebagai input. Set None kalau pakai filename.
  • verbose: Tingkat detail output — 0 minimal, 1 sedang, 2 detail penuh.
  • chart_format: Format visualisasi — "html" untuk interaktif, "svg" atau "png" untuk statis, "bokeh" untuk Bokeh interaktif, "server" untuk Bokeh server.
  • max_rows_analyzed: Jumlah maksimum baris yang dianalisis (sampling otomatis kalau melebihi).
  • max_cols_analyzed: Jumlah maksimum kolom yang dianalisis (pemilihan fitur otomatis kalau melebihi).

Jenis Visualisasi yang Dihasilkan

AutoViz otomatis menghasilkan berbagai jenis visualisasi berdasarkan tipe data:

from autoviz import AutoViz_Class
import pandas as pd

df = pd.read_csv("https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv")

AV = AutoViz_Class()

# Dengan verbose=2 untuk melihat semua detail
df_viz = AV.AutoViz(
    filename="",
    sep=",",
    depVar="Survived",
    dfte=df,
    header=0,
    verbose=2,
    chart_format="html"
)

Jenis visualisasi yang dihasilkan meliputi:

  • Distribusi variabel numerik: Histogram dan KDE plot untuk setiap variabel numerik.
  • Distribusi variabel kategorikal: Bar chart untuk setiap variabel kategorikal.
  • Scatter plot: Hubungan antar variabel numerik, diwarnai berdasarkan target kalau ditentukan.
  • Box plot: Distribusi variabel numerik dikelompokkan berdasarkan variabel kategorikal.
  • Heatmap korelasi: Matriks korelasi antar variabel numerik.
  • Violin plot: Distribusi yang lebih detail dibanding box plot.
  • Pair plot: Matriks scatter plot untuk variabel-variabel paling penting.

Penggunaan dengan Berbagai Format Output

from autoviz import AutoViz_Class
import pandas as pd

df = pd.read_csv("https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv")
AV = AutoViz_Class()

# Output sebagai gambar SVG (cocok untuk laporan)
df_viz = AV.AutoViz(
    filename="",
    depVar="Survived",
    dfte=df,
    verbose=1,
    chart_format="svg"
)

# Output sebagai Bokeh interaktif (cocok untuk presentasi)
df_viz = AV.AutoViz(
    filename="",
    depVar="Survived",
    dfte=df,
    verbose=1,
    chart_format="bokeh"
)

Tabel Perbandingan Komprehensif

Nah, sekarang pertanyaan besarnya: tool mana yang harus dipilih? Berikut perbandingan menyeluruh keempat tools yang sudah kita bahas:

Aspek ydata-profiling Sweetviz DataPrep.EDA AutoViz
Versi Terbaru (2026) 4.16.1 2.x 0.4.x 0.1.x
Python Support >=3.10, <3.14 >=3.8 >=3.8 >=3.8
Backend Komputasi Pandas / Spark Pandas Dask Pandas / Matplotlib / Bokeh
Performa (Dataset Kecil <10K baris) Baik Sangat Baik Sangat Baik Sangat Baik
Performa (Dataset Besar >1M baris) Baik (Spark) Lambat Sangat Baik (Dask) Baik (sampling)
Format Output HTML, JSON, Notebook Widget HTML, Notebook Interaktif (Plotly), HTML HTML, SVG, PNG, Bokeh
Kelengkapan Statistik Sangat Lengkap Lengkap Lengkap Dasar
Analisis Korelasi 5 metode (Pearson, Spearman, Kendall, Phi_k, Cramér's V) Asosiasi numerik dan kategorikal Pearson, Spearman, Kendall Pearson (heatmap)
Analisis Missing Values Sangat Detail (bar, matrix, heatmap, dendrogram) Dasar (persentase) Sangat Detail (modular) Dasar
Perbandingan Dataset Ya Ya (unggulan) Ya (plot_diff) Tidak
Target Analysis Ya Ya (unggulan) Ya Ya
Deteksi Outlier Ya Tidak langsung Ya Terbatas
Deteksi Duplikat Ya Ya Ya Tidak
Kemudahan Penggunaan Mudah Sangat Mudah Mudah (modular) Sangat Mudah (1 baris)
Kustomisasi Sangat Fleksibel Sedang Fleksibel Terbatas
Dukungan Big Data Ya (Spark) Tidak Ya (Dask) Terbatas (sampling)
Masalah Kompatibilitas Minimal NumPy 2.0+ Minimal Minimal
Lisensi MIT MIT MIT Apache 2.0

Best Practices: Memilih Tool yang Tepat dan Tips Penggunaan

Panduan Memilih Tool Berdasarkan Skenario

Oke, jadi tool mana yang harus kamu pilih? Jawabannya: tergantung. Tergantung konteks dan kebutuhan spesifik proyekmu. Ini panduan praktisnya:

  1. Butuh laporan paling komprehensif?

    Pilih ydata-profiling. Nggak ada tool lain yang menandingi kelengkapan statistik dan analisisnya. Dari distribusi variabel, korelasi multi-metode, analisis missing values yang detail, sampai deteksi outlier — semuanya ada dalam satu laporan.

  2. Perlu membandingkan dataset?

    Pilih Sweetviz. Fungsi compare() dan compare_intra()-nya menjadikan Sweetviz pilihan terbaik untuk membandingkan distribusi data training vs testing, atau segmen-segmen dalam dataset.

  3. Kerja dengan dataset besar?

    Pilih DataPrep.EDA untuk dataset yang muat di memori tapi besar (ratusan ribu sampai jutaan baris), atau ydata-profiling dengan Spark untuk yang nggak muat di memori sama sekali.

  4. Mau eksplorasi visual cepat?

    Pilih AutoViz. Satu baris kode, langsung dapat semua visualisasi penting tanpa mikir konfigurasi.

  5. Butuh analisis modular?

    Pilih DataPrep.EDA. Pendekatan function-based-nya memungkinkan kamu fokus ke aspek tertentu tanpa nunggu laporan lengkap selesai.

Tips Umum untuk Automated EDA

  • Jangan cuma andalkan automated EDA:

    Tools otomatis memang berguna buat eksplorasi awal, tapi insight mendalam sering kali butuh analisis manual yang disesuaikan dengan domain masalah. Pakai automated EDA sebagai titik awal, bukan keseluruhan analisis.

  • Pakai mode minimal untuk dataset besar:

    Sebagian besar tools punya opsi mode minimal atau sampling. Aktifkan saat kerja dengan dataset besar supaya nggak nunggu lama. Di ydata-profiling, pakai minimal=True. Di AutoViz, atur max_rows_analyzed sesuai kebutuhan.

  • Simpan dan versikan laporan EDA:

    Laporan HTML sebaiknya disimpan bareng kode dan data sebagai bagian dari dokumentasi proyek. Ini memudahkan tim melacak perubahan karakteristik data seiring waktu.

  • Perhatikan tipe data sebelum jalankan EDA:

    Pastikan kolom-kolom di DataFrame punya tipe data yang benar. Kolom numerik yang terbaca sebagai string bakal menghasilkan analisis yang keliru. Lakukan konversi tipe data dulu sebelum menjalankan EDA.

  • Gunakan virtual environment:

    Mengingat potensi konflik dependensi (kayak masalah Sweetviz dengan NumPy 2.0+), sangat disarankan pakai virtual environment terpisah untuk setiap proyek. Percayalah, ini bakal menghemat banyak sakit kepala.

  • Kombinasikan beberapa tools:

    Nggak ada satu tool yang sempurna untuk semua kebutuhan. Pertimbangkan kombinasi — misalnya AutoViz untuk eksplorasi visual cepat, lalu ydata-profiling untuk analisis statistik mendalam.

Tips Performa

import pandas as pd

# Tips 1: Optimasi tipe data sebelum EDA
def optimize_dtypes(df):
    """Mengoptimasi tipe data DataFrame untuk mengurangi penggunaan memori."""
    for col in df.select_dtypes(include=['int64']).columns:
        df[col] = pd.to_numeric(df[col], downcast='integer')
    for col in df.select_dtypes(include=['float64']).columns:
        df[col] = pd.to_numeric(df[col], downcast='float')
    for col in df.select_dtypes(include=['object']).columns:
        if df[col].nunique() / len(df) < 0.5:
            df[col] = df[col].astype('category')
    return df

df = pd.read_csv("dataset_besar.csv")
df = optimize_dtypes(df)

# Tips 2: Sampling untuk dataset besar sebelum EDA
if len(df) > 100000:
    df_sample = df.sample(n=100000, random_state=42)
else:
    df_sample = df

# Tips 3: Pilih kolom yang relevan saja
kolom_penting = ["Age", "Fare", "Pclass", "Sex", "Survived"]
df_subset = df[kolom_penting]

Integrasi dengan Alur Kerja Machine Learning dan Jupyter Notebook

EDA dalam Pipeline Machine Learning

Automated EDA bukan sesuatu yang berdiri sendiri — ini bagian dari pipeline machine learning yang lebih besar. Berikut contoh bagaimana mengintegrasikan automated EDA ke alur kerja ML yang terstruktur:

import pandas as pd
from sklearn.model_selection import train_test_split
from ydata_profiling import ProfileReport
import sweetviz as sv
from dataprep.eda import plot, plot_missing

# ===== TAHAP 1: Memuat Data =====
df = pd.read_csv("https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv")

# ===== TAHAP 2: EDA Awal dengan ydata-profiling =====
# Memahami dataset secara menyeluruh
initial_profile = ProfileReport(df, title="EDA Awal - Titanic", minimal=True)
initial_profile.to_file("01_initial_eda.html")

# ===== TAHAP 3: Analisis Missing Values dengan DataPrep =====
# Memahami pola missing values sebelum imputasi
plot_missing(df)

# ===== TAHAP 4: Data Preprocessing =====
# Imputasi berdasarkan insight dari EDA
df["Age"].fillna(df["Age"].median(), inplace=True)
df["Embarked"].fillna(df["Embarked"].mode()[0], inplace=True)
df.drop(columns=["Cabin", "Ticket", "Name", "PassengerId"], inplace=True)

# ===== TAHAP 5: Split Data =====
train_df, test_df = train_test_split(df, test_size=0.2, random_state=42, stratify=df["Survived"])

# ===== TAHAP 6: Validasi Split dengan Sweetviz =====
# Memastikan distribusi train dan test konsisten
comparison = sv.compare(
    [train_df, "Training"],
    [test_df, "Testing"],
    target_feat="Survived"
)
comparison.show_html("02_train_test_comparison.html")

# ===== TAHAP 7: EDA Post-Processing =====
# Memverifikasi data setelah preprocessing
post_profile = ProfileReport(train_df, title="EDA Post-Processing - Training", minimal=True)
post_profile.to_file("03_post_processing_eda.html")

print("Pipeline EDA selesai! Laporan tersedia di folder saat ini.")

Integrasi dengan Jupyter Notebook

Semua tools yang kita bahas punya integrasi yang oke dengan Jupyter Notebook. Berikut praktik terbaiknya:

# Cell 1: Setup dan Import
import pandas as pd
import warnings
warnings.filterwarnings('ignore')

# Cell 2: Memuat Data
df = pd.read_csv("https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv")
print(f"Dataset shape: {df.shape}")
print(f"Columns: {list(df.columns)}")

# Cell 3: Quick Visual EDA dengan AutoViz
from autoviz import AutoViz_Class
AV = AutoViz_Class()
df_viz = AV.AutoViz(
    filename="",
    depVar="Survived",
    dfte=df,
    verbose=1,
    chart_format="html"
)

# Cell 4: Profiling Detail dengan ydata-profiling
from ydata_profiling import ProfileReport
profile = ProfileReport(df, title="Titanic EDA", explorative=True)
profile.to_notebook_iframe()

# Cell 5: Analisis Spesifik dengan DataPrep
from dataprep.eda import plot, plot_correlation, plot_missing

# Distribusi usia
plot(df, "Age")

# Cell 6: Korelasi
plot_correlation(df)

# Cell 7: Missing Values
plot_missing(df)

Membuat Fungsi Utilitas EDA

Untuk proyek yang lebih besar, ada baiknya bikin fungsi utilitas yang mengenkapsulasi proses EDA. Ini salah satu contoh yang sering saya pakai (dengan sedikit modifikasi sesuai kebutuhan proyek):

import pandas as pd
from ydata_profiling import ProfileReport
from dataprep.eda import create_report as dp_report

def automated_eda_pipeline(
    df: pd.DataFrame,
    target_col: str = None,
    output_dir: str = "./eda_reports",
    tools: list = ["ydata", "dataprep"],
    minimal: bool = False
) -> dict:
    """
    Menjalankan automated EDA pipeline dengan multiple tools.

    Parameters:
    -----------
    df : pd.DataFrame
        DataFrame yang akan dianalisis
    target_col : str, optional
        Nama kolom target
    output_dir : str
        Direktori output untuk laporan
    tools : list
        Daftar tools yang akan digunakan
    minimal : bool
        Mode minimal untuk dataset besar

    Returns:
    --------
    dict : Dictionary berisi path ke laporan yang dihasilkan
    """
    import os
    os.makedirs(output_dir, exist_ok=True)
    reports = {}

    if "ydata" in tools:
        print("Membuat laporan ydata-profiling...")
        profile = ProfileReport(
            df,
            title="Automated EDA Report",
            explorative=not minimal,
            minimal=minimal
        )
        path = os.path.join(output_dir, "ydata_profiling_report.html")
        profile.to_file(path)
        reports["ydata-profiling"] = path
        print(f"  Laporan tersimpan: {path}")

    if "dataprep" in tools:
        print("Membuat laporan DataPrep...")
        report = dp_report(df, title="DataPrep EDA Report")
        path = os.path.join(output_dir, "dataprep_report.html")
        report.save(path)
        reports["dataprep"] = path
        print(f"  Laporan tersimpan: {path}")

    if "sweetviz" in tools:
        import sweetviz as sv
        print("Membuat laporan Sweetviz...")
        if target_col:
            report = sv.analyze(df, target_feat=target_col)
        else:
            report = sv.analyze(df)
        path = os.path.join(output_dir, "sweetviz_report.html")
        report.show_html(filepath=path, open_browser=False)
        reports["sweetviz"] = path
        print(f"  Laporan tersimpan: {path}")

    if "autoviz" in tools:
        from autoviz import AutoViz_Class
        print("Membuat visualisasi AutoViz...")
        AV = AutoViz_Class()
        AV.AutoViz(
            filename="",
            depVar=target_col if target_col else "",
            dfte=df,
            verbose=0,
            chart_format="html"
        )
        reports["autoviz"] = "Visualisasi ditampilkan inline"
        print("  Visualisasi AutoViz selesai.")

    print(f"\nTotal laporan dihasilkan: {len(reports)}")
    return reports

# Penggunaan:
df = pd.read_csv("https://raw.githubusercontent.com/datasciencedojo/datasets/master/titanic.csv")
reports = automated_eda_pipeline(
    df,
    target_col="Survived",
    output_dir="./titanic_eda",
    tools=["ydata", "dataprep", "sweetviz"],
    minimal=False
)

Integrasi dengan CI/CD dan Automasi

Automated EDA juga bisa diintegrasikan ke pipeline CI/CD untuk monitoring kualitas data secara otomatis. Ini contoh script yang bisa dijalankan sebagai bagian dari cron job atau pipeline:

# script: eda_monitor.py
# Jalankan sebagai bagian dari pipeline CI/CD atau cron job

import pandas as pd
import sys
import json
from datetime import datetime
from ydata_profiling import ProfileReport

def monitor_data_quality(data_path: str, baseline_path: str = None):
    """
    Monitor kualitas data dan hasilkan laporan.
    Mengembalikan exit code 1 jika ada masalah kualitas data.
    """
    df = pd.read_csv(data_path)

    # Membuat profil
    profile = ProfileReport(df, minimal=True)
    description = profile.get_description()

    # Ekstrak metrik kualitas
    quality_metrics = {
        "timestamp": datetime.now().isoformat(),
        "n_rows": len(df),
        "n_columns": len(df.columns),
        "missing_percentage": (df.isnull().sum().sum() / (len(df) * len(df.columns))) * 100,
        "duplicate_rows": df.duplicated().sum(),
        "duplicate_percentage": (df.duplicated().sum() / len(df)) * 100,
    }

    # Simpan metrik
    with open("data_quality_metrics.json", "w") as f:
        json.dump(quality_metrics, f, indent=2)

    # Simpan laporan lengkap
    report_name = f"eda_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.html"
    profile.to_file(report_name)

    # Cek threshold kualitas
    if quality_metrics["missing_percentage"] > 30:
        print(f"PERINGATAN: Missing values terlalu tinggi ({quality_metrics['missing_percentage']:.1f}%)")
        return 1

    if quality_metrics["duplicate_percentage"] > 10:
        print(f"PERINGATAN: Duplikat terlalu banyak ({quality_metrics['duplicate_percentage']:.1f}%)")
        return 1

    print("Semua metrik kualitas data dalam batas normal.")
    return 0

if __name__ == "__main__":
    exit_code = monitor_data_quality(sys.argv[1])
    sys.exit(exit_code)

Kesimpulan

Automated EDA sudah jadi bagian yang nggak terpisahkan dari toolkit setiap data scientist di 2026. Keempat tools yang kita bahas — ydata-profiling, Sweetviz, DataPrep.EDA, dan AutoViz — masing-masing punya kekuatan unik yang saling melengkapi.

ydata-profiling tetap jadi raja untuk profiling komprehensif, apalagi dengan dukungan Spark-nya. Versi 4.16.1 memberikan stabilitas dan kelengkapan fitur yang susah ditandingi. Kalau cuma boleh pilih satu, ini pilihan paling aman.

Sweetviz unggul di skenario perbandingan dataset dan analisis target. Visualisasinya estetis dan compare_intra()-nya unik. Memang ada isu kompatibilitas NumPy 2.0+, tapi itu bukan deal breaker.

DataPrep.EDA menawarkan kombinasi terbaik antara kecepatan dan modularitas. Backend Dask-nya yang bisa 10x lebih cepat dari pandas bikin DataPrep jadi pilihan ideal untuk dataset besar. Pendekatan function-based-nya juga kasih fleksibilitas yang nggak dimiliki tools lain.

AutoViz adalah solusi tercepat buat dapat gambaran visual dari data. Satu baris kode, langsung jadi. Sempurna buat eksplorasi awal, terutama saat baru pertama kali kenalan dengan dataset.

Rekomendasi saya? Pahami kekuatan dan keterbatasan masing-masing tool, lalu gunakan secara komplementer. Mulai dengan AutoViz untuk eksplorasi visual cepat, pakai DataPrep.EDA untuk analisis modular, manfaatkan ydata-profiling untuk laporan komprehensif, dan andalkan Sweetviz saat butuh membandingkan dataset.

Dan yang paling penting — ingat bahwa automated EDA itu alat bantu, bukan pengganti pemikiran kritis. Insight terbaik tetap datang dari kombinasi analisis otomatis dan pemahaman domain yang mendalam. Gunakan laporan yang dihasilkan sebagai titik awal investigasi, bukan kesimpulan akhir.

So, selamat mengeksplorasi data kamu dengan lebih efisien!

Tentang Penulis Editorial Team

Our team of expert writers and editors.

Artikel Terkait