Deep Learning vs Machine Learning

Setiap kali deep learning dibahas, pertanyaan pertama yang muncul biasanya: apa bedanya dengan machine learning biasa? Keduanya sama-sama belajar dari data, sama-sama dievaluasi dengan akurasi, dan sama-sama membutuhkan pemisahan data latih dan data uji. Perbedaan utamanya justru terletak pada satu keputusan desain yang tampak sepele tetapi berdampak besar: siapa yang merancang fitur. Chapter ini membedah perbedaan tersebut lewat eksperimen terukur pada dataset digits, lalu merangkumnya ke dalam tabel yang bisa dipakai saat memilih pendekatan untuk masalah Anda.

Titik Perbedaan Utama: Siapa yang Merancang Fitur #

Pada machine learning klasik, manusia merancang fitur secara manual — pekerjaan yang disebut feature engineering. Untuk mendeteksi pesan tidak diinginkan, misalnya, insinyur memilih fitur seperti panjang pesan, jumlah tautan, dan kemunculan kata tertentu. Model seperti random forest atau regresi kemudian hanya belajar memetakan fitur tersebut ke keputusan. Kualitas model dengan demikian dibatasi oleh kecermatan manusia merancang fitur.

Deep learning memindahkan pekerjaan itu ke dalam model. Data mentah — piksel, cuplikan suara, urutan kata — masuk apa adanya, lalu layer-layer neural network menyusun representasi bertingkat sebagaimana kita tiru pada Chapter sebelumnya. Pada pesan berbahasa Inggris, layer awal bisa mempelajari deteksi karakter, layer tengah mengenali kata dan frasa, dan layer akhir menangkap makna. Semua tingkatan dipelajari dari data, bukan ditulis manual.

Eksperimen Terukur: Fitur Buatan vs Piksel Mentah #

Klaim “fitur otomatis lebih baik” tidak perlu dipercaya begitu saja; kita bisa mengukurnya. Eksperimen berikut memakai dataset digits, model yang sama persis (LogisticRegression ), dan pembagian data yang sama. Yang berbeda hanya fiturnya: pendekatan A memakai tiga fitur yang kita rancang sendiri, pendekatan B memakai 64 piksel mentah tanpa penyusutan apa pun.

"""Perbandingan fitur buatan tangan vs piksel mentah pada digits.

Pendekatan machine learning klasik bergantung pada fitur yang
dirancang manual. Pendekatan deep learning menyerahkan pekerjaan
itu ke model. Kode ini mengukur dampaknya secara nyata dengan
LogisticRegression pada dataset digits.
"""

import numpy as np
from sklearn.datasets import load_digits
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

fitur_mentah, label = load_digits(return_X_y=True)
latih, uji, label_latih, label_uji = train_test_split(
    fitur_mentah, label, test_size=0.25, random_state=42, stratify=label
)


def ekstraksi_fitur(gambar):
    """Rancang 3 fitur manual dari satu citra 8x8."""
    intensitas = gambar.mean()                      # seberapa gelap angka
    simetri = -np.abs(gambar - gambar[:, ::-1]).mean()  # cermin kiri-kanan
    ketajaman = (
        np.abs(np.diff(gambar, axis=0)).mean()
        + np.abs(np.diff(gambar, axis=1)).mean()
    )                                               # seberapa banyak tepi
    return [intensitas, simetri, ketajaman]


# Pendekatan A: 3 fitur yang kita rancang sendiri
gambar_latih = latih.reshape(-1, 8, 8)
gambar_uji = uji.reshape(-1, 8, 8)
fitur_latih = np.array([ekstraksi_fitur(g) for g in gambar_latih])
fitur_uji = np.array([ekstraksi_fitur(g) for g in gambar_uji])

model_fitur = LogisticRegression(max_iter=5000).fit(fitur_latih, label_latih)
akurasi_fitur = model_fitur.score(fitur_uji, label_uji)

# Pendekatan B: seluruh 64 piksel sebagai fitur
model_piksel = LogisticRegression(max_iter=5000).fit(latih, label_latih)
akurasi_piksel = model_piksel.score(uji, label_uji)

print(f"Akurasi dengan 3 fitur buatan tangan : {akurasi_fitur:.3f}")
print(f"Akurasi dengan 64 piksel mentah      : {akurasi_piksel:.3f}")
print(f"Selisih                               : {akurasi_piksel - akurasi_fitur:.3f}")

Output yang Dihasilkan:

Akurasi dengan 3 fitur buatan tangan : 0.364
Akurasi dengan 64 piksel mentah      : 0.960
Selisih                               : 0.596

Hasilnya cukup menyolok. Tiga fitur yang terdengar masuk akal — intensitas, simetri, ketajaman — hanya mencapai akurasi 36,4 persen, hampir setara menebak. Masalahnya, ketiga angka itu meratakan seluruh citra menjadi ringkasan global, sehingga informasi bentuk lokal yang membedakan angka 3 dan angka 8 ikut terhapus. Piksel mentah mempertahankan seluruh informasi spasial dan langsung melonjak ke 96 persen — dan itu pun masih model linear. Neural network berlapis menambah kemampuan menyusun fitur bertingkat di atas piksel tersebut, sehingga pada data besar dan kompleks jurangnya makin lebar.

Mari kita telaah kode di atas baris per baris:

1. Baris 14-17: memuat dataset digits lalu membaginya dengan train_test_split ; random_state=42 dan stratify=label menjaga hasil konsisten saat kode diulang.
2. Baris 20-28: fungsi ekstraksi_fitur merancang tiga fitur manual — rata-rata intensitas piksel, tingkat simetri cermin kiri-kanan, dan rata-rata selisih piksel tetangga sebagai ukuran banyaknya tepi.
3. Baris 31-35: mengubah data 64 kolom menjadi citra 8x8 dengan reshape, lalu menerapkan ekstraksi_fitur pada setiap citra latih dan uji.
4. Baris 37-38: melatih LogisticRegression pada tiga fitur buatan; max_iter=5000 memberi waktu solver menyelesaikan optimasi; score menghitung akurasi pada data uji.
5. Baris 40-42: melatih model kedua dengan data, pembagian, dan pengaturan yang sama — hanya fiturnya yang diganti 64 piksel mentah.
6. Baris 44-46: mencetak kedua akurasi beserta selisihnya.

Perbandingan Menyeluruh #

Selain fitur, ada empat dimensi lain yang layak dipertimbangkan. Tabel berikut merangkum keseluruhan gambaran:

Interpretabilitas sering menjadi penentu di domain yang teregulasi. Untuk keputusan kredit atau diagnosis medis, kemampuan menjelaskan “fitur apa yang mendorong keputusan ini” bisa menjadi syarat, bukan pelengkap. Di titik itu model linear atau pohon keputusan masih sulit digantikan.

Kapan Memilih yang Mana #

Kedua pendekatan saling melengkapi, bukan saling menggantikan. Sebagai pegangan cepat:

• Pilih machine learning klasik ketika data tabular berukuran kecil hingga sedang, interpretasi keputusan penting, komputasi terbatas, atau waktu pengerjaan ketat.
• Pilih deep learning ketika data tidak terstruktur dalam jumlah besar, polanya kompleks, akurasi menjadi prioritas utama, dan sumber daya komputasi tersedia.
• Kombinasikan keduanya ketika DL memproses data mentah (misalnya mengubah dokumen menjadi embedding) lalu model klasik menyelesaikan keputusan akhir di atasnya.

Peta perbedaan kini jelas: machine learning klasik unggul ketika fitur bisa dirancang manusia, deep learning unggul ketika representasi terbaik justru harus dipelajari dari data. Pertanyaan teknis berikutnya mengikuti secara alami: bagaimana persisnya parameter itu dipelajari? Chapter berikutnya membedah siklus training neural network — forward pass, loss, backward pass, pembaruan bobot — dengan neuron pertama yang kita latih dari nol menggunakan NumPy.