Tutorial Machine Learning Python untuk Pemula dengan Contoh Sederhana

Machine learning merupakan salah satu cabang Artificial Intelligence (AI) yang memungkinkan komputer mempelajari pola dari data untuk membuat prediksi atau mengambil keputusan berdasarkan pola tersebut. Dengan Python, proses ini dapat dipelajari secara bertahap, mulai dari menyiapkan dataset, melatih model, hingga mengevaluasi hasil prediksi.

Dalam tutorial machine learning Python ini, kita akan membangun model klasifikasi sederhana menggunakan dataset Iris dan pustaka Scikit-learn. Contoh ini cocok untuk pemula yang ingin belajar AI Python melalui praktik langsung tanpa harus membangun algoritma machine learning dari awal.

1. Memahami Machine Learning

Machine learning adalah pendekatan dalam AI yang menggunakan data untuk membangun model komputasi. Model tersebut mempelajari hubungan atau pola dari contoh yang diberikan, kemudian menggunakan hasil pembelajaran untuk memprediksi data yang belum pernah dilihat sebelumnya.

Perbedaan utamanya dengan pemrograman berbasis aturan biasa terletak pada cara sistem memperoleh perilaku prediktifnya.

Machine learning bukan berarti komputer otomatis memahami segala sesuatu seperti manusia. Hasilnya bergantung pada data, pemilihan algoritma, proses pelatihan, dan cara model dievaluasi.

2. Alur Kerja Machine Learning

Sebelum menulis kode, pahami terlebih dahulu tahapan yang akan kita jalankan. Proyek machine learning sederhana biasanya mengikuti alur berikut.

Alur tersebut merupakan fondasi yang dapat digunakan kembali ketika kamu mempelajari klasifikasi gambar, analisis teks, prediksi harga, maupun proyek machine learning lainnya.

3. Persiapan Python dan Scikit-learn

Kita menggunakan Python karena sintaksnya relatif mudah dibaca dan ekosistemnya menyediakan banyak pustaka untuk pengolahan data serta machine learning. Salah satu pustaka yang cocok untuk pemula adalah Scikit-learn.

Pastikan Python sudah terpasang di komputer. Periksa instalasinya melalui terminal atau Command Prompt:

python --version

Jika versi Python muncul, lanjutkan dengan memasang pustaka yang diperlukan:

python -m pip install scikit-learn

Scikit-learn menyediakan dataset contoh, algoritma klasifikasi, fungsi pembagian data, serta alat evaluasi sehingga kita tidak perlu membangun seluruh komponen tersebut secara manual.

Membuat file Python

Buat file bernama tutorial_ml_iris.py. Kamu dapat menggunakan VS Code atau editor teks lain. Seluruh contoh kode berikut akan dimasukkan ke file tersebut secara bertahap.

4. Mengenal Dataset Iris

Dataset Iris adalah dataset klasik untuk mempelajari klasifikasi. Dataset bawaan Scikit-learn ini berisi 150 sampel bunga dengan empat fitur numerik dan tiga kelas spesies.

Target yang akan diprediksi adalah salah satu dari tiga spesies: setosa, versicolor, atau virginica.

Dalam machine learning, fitur adalah informasi yang digunakan model untuk membuat prediksi, sedangkan target adalah nilai yang ingin diprediksi. Karena dataset Iris sudah disediakan oleh Scikit-learn, kita dapat langsung berlatih tanpa mengunduh atau membuat dataset secara manual.

5. Memuat dan Memeriksa Data

Langkah pertama adalah memuat dataset dan memahami struktur datanya. Tambahkan kode berikut ke file Python yang sudah dibuat:

from sklearn.datasets import load_iris

# Memuat dataset Iris
iris = load_iris()

# Memisahkan fitur dan target
X = iris.data
y = iris.target

print("Jumlah sampel:", X.shape[0])
print("Jumlah fitur:", X.shape[1])
print("Nama fitur:", iris.feature_names)
print("Nama kelas:", iris.target_names)
print("Lima sampel pertama:")
print(X[:5])
print("Lima target pertama:")
print(y[:5])

Penjelasan setiap bagian:

• load_iris() memuat dataset contoh yang tersedia di Scikit-learn.
• iris.data berisi matriks fitur yang digunakan sebagai input model.
• iris.target berisi label kelas dalam bentuk angka.
• X.shape memberikan informasi tentang jumlah sampel dan fitur.
• iris.target_names berisi nama spesies yang mewakili label kelas.

Output utamanya akan menunjukkan 150 sampel, empat fitur, dan tiga kelas. Lima target pertama pada dataset bawaan ini bernilai nol karena sampel awal termasuk kelas setosa.

Perhatikan bahwa model akan menerima angka sebagai input dan memprediksi label kelas. Kita akan menggunakan nama spesies untuk membuat hasil prediksi lebih mudah dibaca manusia.

6. Membagi Data Training dan Testing

Salah satu kesalahan umum ketika belajar machine learning adalah menguji model menggunakan data yang sama dengan data pelatihannya. Hasil evaluasi seperti itu tidak memberikan gambaran yang cukup baik tentang kemampuan model menghadapi data baru.

Untuk menghindarinya, kita membagi dataset menjadi dua bagian:

• Data training: digunakan untuk melatih model agar mempelajari pola.
• Data testing: digunakan untuk mengukur kemampuan model pada sampel yang tidak dipakai saat pelatihan.

Kita menggunakan 80% data untuk pelatihan dan 20% untuk pengujian. Fungsi train_test_split() akan melakukan pembagian tersebut.

from sklearn.model_selection import train_test_split

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

print("Data training:", X_train.shape[0])
print("Data testing:", X_test.shape[0])

Hasil yang diharapkan adalah 120 sampel untuk training dan 30 sampel untuk testing.

Parameter test_size=0.2 menentukan proporsi data pengujian. random_state=42 membuat pembagian dapat direproduksi ketika dataset dan konfigurasi yang digunakan sama. Sementara itu, stratify=y menjaga proporsi kelas pada kedua bagian agar kurang lebih sama dengan proporsi kelas dalam dataset awal.

7. Melatih Model Machine Learning

Sekarang kita akan menggunakan algoritma Decision Tree. Algoritma ini membangun serangkaian aturan berdasarkan fitur untuk menentukan kelas suatu sampel. Struktur pohonnya relatif mudah dipahami sehingga cocok untuk demonstrasi klasifikasi awal.

Tambahkan kode berikut setelah proses pembagian data:

from sklearn.tree import DecisionTreeClassifier

# Membuat model klasifikasi
model = DecisionTreeClassifier(random_state=42)

# Melatih model dengan data training
model.fit(X_train, y_train)

print("Model selesai dilatih.")

Bagian terpenting di sini adalah metode fit(). Metode tersebut menjalankan proses pembelajaran berdasarkan fitur X_train dan label yang benar y_train.

Setelah pelatihan selesai, model memiliki aturan keputusan yang dipelajari dari sampel training. Model belum otomatis menjadi sempurna. Kita masih harus mengujinya menggunakan data testing untuk melihat apakah pola yang dipelajari dapat diterapkan pada sampel lain.

Apa yang sebenarnya dipelajari model?

Decision Tree mencari pemisahan fitur yang membantu membedakan kelas. Misalnya, ukuran petal tertentu dapat membantu memisahkan sampel setosa dari dua kelas lainnya. Model membentuk keputusan berdasarkan data pelatihan, bukan berdasarkan pemahaman biologis seperti yang dimiliki manusia.

Itulah salah satu contoh cara kerja machine learning: programmer memilih data dan algoritma, sedangkan model menentukan pola pemisah berdasarkan proses pelatihan.

8. Mengevaluasi Hasil Model

Model yang sudah dilatih perlu diuji. Kita akan menggunakan accuracy_score untuk menghitung proporsi prediksi yang benar dan classification_report untuk melihat metrik evaluasi pada setiap kelas.

from sklearn.metrics import accuracy_score, classification_report

# Membuat prediksi dari data testing
y_pred = model.predict(X_test)

# Menghitung akurasi
accuracy = accuracy_score(y_test, y_pred)

print(f"Akurasi model: {accuracy:.2%}")
print("\nLaporan klasifikasi:")
print(
    classification_report(
        y_test,
        y_pred,
        target_names=iris.target_names,
        zero_division=0
    )
)

Metode predict() menghasilkan prediksi untuk setiap sampel pada data testing. Hasilnya kemudian dibandingkan dengan label sebenarnya yang disimpan di y_test.

Memahami akurasi

Akurasi merupakan jumlah prediksi yang benar dibagi dengan jumlah seluruh sampel yang diuji. Jika 29 dari 30 sampel diprediksi dengan benar, akurasinya adalah sekitar 96,67%.

Angka tersebut hanya ilustrasi perhitungan, bukan jaminan hasil eksekusi model ini. Hasil aktual bergantung pada pembagian data, algoritma, parameter, serta versi pustaka yang digunakan.

Memahami precision, recall, dan F1-score

Akurasi mudah dipahami, tetapi tidak selalu cukup. Pada dataset yang sangat tidak seimbang, model dapat memperoleh akurasi tinggi dengan lebih sering memprediksi kelas mayoritas. Karena itu, precision, recall, F1-score, dan distribusi kelas perlu diperiksa sesuai tujuan aplikasi.

9. Membuat Prediksi Data Baru

Setelah mengevaluasi model, kita dapat mencoba memberikan satu sampel baru dengan empat fitur yang sesuai urutan dataset Iris. Nilai berikut digunakan sebagai contoh pengukuran bunga, bukan data dari pengukuran lapangan tertentu.

# Contoh fitur: sepal length, sepal width,
# petal length, dan petal width dalam sentimeter
sampel_baru = [[5.1, 3.5, 1.4, 0.2]]

# Prediksi label kelas
prediksi = model.predict(sampel_baru)

# Mengubah label angka menjadi nama spesies
nama_spesies = iris.target_names[prediksi[0]]

print("Prediksi spesies:", nama_spesies)

Output yang diharapkan untuk sampel tersebut adalah setosa. Model membuat prediksi berdasarkan pola yang dipelajari dari data training.

Urutan fitur sangat penting. Jika kamu menukar posisi panjang petal dengan lebar petal, model tetap akan menerima angka tersebut, tetapi maknanya menjadi berbeda. Kesalahan susunan input dapat menyebabkan prediksi yang tidak dapat diandalkan.

Melihat probabilitas prediksi

Decision Tree juga dapat memberikan estimasi probabilitas untuk setiap kelas berdasarkan distribusi kelas pada daun pohon yang menerima sampel tersebut.

probabilitas = model.predict_proba(sampel_baru)[0]

for nama, nilai in zip(iris.target_names, probabilitas):
    print(f"{nama}: {nilai:.2%}")

Nilai probabilitas ini bukan ukuran kepastian mutlak bahwa prediksi benar. Probabilitas dari suatu model dapat tidak terkalibrasi dengan baik, sehingga interpretasinya harus mempertimbangkan karakteristik algoritma dan data.

10. Bereksperimen dengan Model

Belajar AI Python tidak berhenti setelah model berhasil berjalan. Kamu perlu mencoba perubahan kecil, mengamati hasilnya, dan memahami alasan di balik perubahan tersebut.

Membatasi kedalaman Decision Tree

Decision Tree yang terlalu kompleks dapat mempelajari detail khusus pada data training sehingga kurang mampu melakukan generalisasi. Salah satu cara mengendalikan kompleksitasnya adalah mengatur parameter max_depth.

from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

model_sederhana = DecisionTreeClassifier(
    max_depth=2,
    random_state=42
)

model_sederhana.fit(X_train, y_train)

prediksi_sederhana = model_sederhana.predict(X_test)

print(
    "Akurasi model sederhana:",
    f"{accuracy_score(y_test, prediksi_sederhana):.2%}"
)

Bandingkan hasilnya dengan model sebelumnya. Model dengan kedalaman lebih kecil biasanya memiliki struktur yang lebih sederhana, tetapi dapat kehilangan kemampuan untuk menangkap pola tertentu. Tidak ada satu nilai max_depth yang selalu terbaik untuk semua dataset.

Membandingkan model training dan testing

Kamu juga dapat menghitung akurasi pada data training dan testing untuk melihat indikasi awal apakah model terlalu menyesuaikan diri terhadap data pelatihan.

akurasi_training = accuracy_score(
    y_train,
    model.predict(X_train)
)

akurasi_testing = accuracy_score(
    y_test,
    model.predict(X_test)
)

print(f"Akurasi training: {akurasi_training:.2%}")
print(f"Akurasi testing: {akurasi_testing:.2%}")

Jika akurasi training jauh lebih tinggi daripada testing, model mungkin mengalami overfitting. Namun, selisih tersebut bukan satu-satunya dasar diagnosis. Ukuran dataset, variasi sampel, kompleksitas model, dan strategi validasi juga perlu diperhatikan.

Mengapa tidak langsung menggunakan model paling akurat?

Memilih model berdasarkan satu angka dari satu pembagian data dapat menghasilkan kesimpulan yang menyesatkan. Dalam proyek nyata, model perlu dinilai berdasarkan kebutuhan pengguna, biaya kesalahan, kestabilan hasil, waktu komputasi, serta kemampuan generalisasi.

Untuk eksperimen lanjutan, kamu dapat mencoba Logistic Regression, K-Nearest Neighbors, atau Random Forest menggunakan pembagian data yang sama. Pastikan setiap model dibandingkan dengan prosedur evaluasi yang konsisten.

11. Kesalahan yang Perlu Dihindari

Ketika mulai mempelajari machine learning, beberapa kesalahan berikut sering membuat hasil eksperimen sulit dipercaya.

12. Kesimpulan

Melalui tutorial machine learning Python ini, kamu telah mempelajari alur dasar membangun model klasifikasi: memuat dataset, memisahkan fitur dan target, membagi data training dan testing, melatih Decision Tree, mengevaluasi hasil, serta memprediksi sampel baru.

Contoh Iris memang sederhana, tetapi prinsip yang dipelajari merupakan fondasi untuk proyek machine learning yang lebih besar. Kamu dapat menerapkannya pada dataset lain dengan menyesuaikan proses pengolahan data, algoritma, dan metrik evaluasi terhadap masalah yang ingin diselesaikan.

Perlu diingat bahwa model yang berjalan bukan berarti model tersebut sudah siap digunakan pada sistem produksi. Aplikasi nyata membutuhkan pengujian lebih luas, pengelolaan data yang baik, pemantauan performa, dan penanganan kesalahan prediksi.

Latihan mandiri

Jika kamu sudah memahami tahapan ini, langkah berikutnya adalah mempelajari cara memilih algoritma, mengolah dataset yang lebih kompleks, dan melakukan validasi model secara sistematis. Dari fondasi tersebut, kamu dapat mulai membangun sistem AI yang benar-benar menyelesaikan masalah tertentu.