Ponsel yang membuka kunci dari wajah pemiliknya, layanan musik yang menyarankan lagu baru, dan kamera yang menajamkan hasil foto bekerja di atas deep learning. Deep learning adalah cabang machine learning yang memanfaatkan jaringan saraf tiruan (neural network) berlapis untuk mengenali pola pada data. Sebelum menulis kode dengan framework apa pun, kita perlu memahami posisi deep learning di dalam peta kecerdasan buatan serta alasan pendekatan berlapis efektif untuk gambar, suara, dan teks. Chapter ini membangun fondasi tersebut melalui diagram, tabel perbandingan, dan contoh NumPy yang dapat dijalankan langsung.

Posisi Deep Learning dalam Peta Kecerdasan Buatan #

Kecerdasan buatan (artificial intelligence, AI) adalah bidang paling luas: semua teknik yang membuat komputer melakukan tugas yang menuntut kecerdasan. Di dalamnya ada machine learning (ML), yaitu pendekatan yang mempelajari pola dari data alih-alih diprogram dengan aturan eksplisit. Deep learning adalah bagian dari machine learning yang memakai neural network dengan banyak layer, sehingga disebut “dalam” (deep). Relasi ketiganya berbentuk lingkaran bersarang, bukan tiga teknologi yang bersaing:

Semua yang dikerjakan deep learning juga merupakan machine learning, dan semuanya berada di dalam wilayah AI. CNN, RNN, dan Transformer pada diagram di atas adalah arsitektur neural network yang akan kita bahas tuntas pada bab-bab selanjutnya; saat ini cukup dipahami sebagai spesialisasi deep learning untuk jenis data tertentu.

Representasi Berlapis: dari Piksel ke Makna #

Kekuatan utama deep learning terletak pada cara model menyusun representasi data secara bertingkat. Satu piksel gambar tidak bermakna; dua puluh piksel yang tersusun membentuk garis mulai bermakna; ribuan piksel yang tersusun membentuk wajah sangat bermakna. Neural network memanfaatkan hierarki tersebut:

  • Layer awal: menangkap tepi, bercak warna, dan perubahan intensitas — pola berukuran beberapa piksel.
  • Layer tengah: menggabungkan tepi menjadi bentuk seperti lingkaran, sudut, dan tekstur.
  • Layer akhir: menyusun bagian objek (roda, mata, tangan) hingga objek utuh (mobil, wajah, angka).

Kita bisa meniru mekanisme intinya dengan NumPy, tanpa framework apa pun. Program berikut mengambil citra angka nol dari dataset digits milik scikit-learn , lalu menerapkan dua transformasi berurutan: deteksi tepi, kemudian agregasi menjadi fitur bentuk. Dataset digits memuat 1.797 citra tulisan tangan angka 0-9 berukuran 8x8 piksel, sehingga ringan untuk dieksperimenkan.

python 
"""Demo transformasi data mentah menjadi fitur berlapis.

Meniru inti cara kerja deep learning: setiap layer mengubah
representasi data sedikit demi sedikit, dari piksel mentah
menjadi pola yang lebih abstrak.
"""

import numpy as np
from sklearn.datasets import load_digits

np.set_printoptions(linewidth=100)

# 1) Data mentah: citra 8x8 piksel milik angka nol
digits = load_digits()
gambar = digits.images[0]

print("Layer 0 -- piksel mentah (8x8, nilai 0-16):")
print(gambar.astype(int))

# 2) Layer pertama: deteksi tepi lewat selisih piksel tetangga
selisih_baris = gambar[1:, :] - gambar[:-1, :]
respons_tepi = np.maximum(0, selisih_baris)  # aktivasi ReLU sederhana

print("\nLayer 1 -- respons tepi antar baris (7x8, nilai >= 0):")
print(respons_tepi.astype(int))

# 3) Layer kedua: agregasi menjadi fitur bentuk (jumlah per kuadran)
fitur = np.array([
    respons_tepi[:4, :4].sum(),
    respons_tepi[:4, 4:].sum(),
    respons_tepi[4:, :4].sum(),
    respons_tepi[4:, 4:].sum(),
])
print("\nLayer 2 -- fitur bentuk (jumlah respons per kuadran):")
print(fitur.astype(int))

# 4) Bandingkan fitur angka nol dengan fitur angka satu
gambar_lain = digits.images[1]
respons_lain = np.maximum(0, gambar_lain[1:, :] - gambar_lain[:-1, :])
fitur_lain = np.array([
    respons_lain[:4, :4].sum(),
    respons_lain[:4, 4:].sum(),
    respons_lain[4:, :4].sum(),
    respons_lain[4:, 4:].sum(),
])
print("\nFitur angka 0 :", fitur.astype(int))
print("Fitur angka 1 :", fitur_lain.astype(int))
print("Jarak fitur   :", int(np.abs(fitur - fitur_lain).sum()))

Output yang Dihasilkan:

text 
Layer 0 -- piksel mentah (8x8, nilai 0-16):
[[ 0  0  5 13  9  1  0  0]
 [ 0  0 13 15 10 15  5  0]
 [ 0  3 15  2  0 11  8  0]
 [ 0  4 12  0  0  8  8  0]
 [ 0  5  8  0  0  9  8  0]
 [ 0  4 11  0  1 12  7  0]
 [ 0  2 14  5 10 12  0  0]
 [ 0  0  6 13 10  0  0  0]]

Layer 1 -- respons tepi antar baris (7x8, nilai >= 0):
[[ 0  0  8  2  1 14  5  0]
 [ 0  3  2  0  0  0  3  0]
 [ 0  1  0  0  0  0  0  0]
 [ 0  1  0  0  0  1  0  0]
 [ 0  0  3  0  1  3  0  0]
 [ 0  0  3  5  9  0  0  0]
 [ 0  0  0  8  0  0  0  0]]

Layer 2 -- fitur bentuk (jumlah respons per kuadran):
[17 24 19 13]

Fitur angka 0 : [17 24 19 13]
Fitur angka 1 : [27  8  0  7]
Jarak fitur   : 51

Perhatikan perubahan representasinya antar layer. Pada layer 1, hanya piksel yang berubah nilai terhadap baris di bawahnya yang bertahan; bagian dalam angka yang rata menjadi nol. Pada layer 2, seluruh informasi terkumpul menjadi empat angka sebaran tepi per kuadran. Fitur angka 0 ([17 24 19 13]) tersebar di empat kuadran karena bentuknya menyerupai cincin, sedangkan fitur angka 1 ([27 8 0 7]) terkumpul di kiri-atas, tempat goresan tegak angka tersebut berada.

Mari kita telaah kode di atas baris per baris:

  1. Baris 8-9: mengimpor NumPy dan fungsi load_digits dari scikit-learn.
  2. Baris 11: np.set_printoptions(linewidth=100) menjaga matriks 8x8 tercetak dalam satu baris.
  3. Baris 14-15: memuat dataset lalu mengambil citra pertama (digits.images[0]), angka nol 8x8.
  4. Baris 21: gambar[1:, :] - gambar[:-1, :] mengurangi tiap baris dengan baris di atasnya sehingga menyoroti piksel yang berubah tajam ke bawah — analog sederhana filter deteksi tepi.
  5. Baris 22: np.maximum(0, ...) memotong nilai negatif menjadi nol, meniru aktivasi ReLU.
  6. Baris 28-33: menjumlahkan respons tepi tiap kuadran 4x4 lewat operasi agregasi ndarray ; empat hasilnya adalah fitur bentuk.
  7. Baris 38-44: mengulang transformasi yang sama pada citra angka satu (digits.images[1]).
  8. Baris 46-48: mencetak kedua vektor fitur beserta jaraknya; jarak 51 menandakan representasi kedua angka terpisah cukup jauh.

Tiga Pendekatan Membangun Perilaku Cerdas #

Sebelum memilih deep learning untuk sebuah masalah, kita perlu melihat alternatifnya secara jujur. Tabel berikut merangkum tiga pendekatan utama dalam AI modern:

AspekAturan eksplisitMachine learning klasikDeep learning
Sumber keputusanManusia menulis aturan jika-makaManusia merancang fitur; model mempelajari polaModel mempelajari fitur dan pola sekaligus
Contoh teknikSistem pakar, filter pesan berbasis kata kunciRegresi linear, random forest, SVMCNN, RNN, Transformer
KekuatanMudah diaudit; tidak butuh data latihAndal pada data tabular berukuran kecil hingga sedangUnggul pada citra, suara, dan teks berskala besar
KelemahanRapuh ketika variasi data bertambahPerforma dibatasi kualitas fitur buatanMembutuhkan data dan komputasi dalam jumlah besar

Aturan eksplisit tetap tepat untuk masalah kecil yang stabil, misalnya validasi format nomor telepon. Machine learning klasik tetap menjadi pilihan wajar untuk data tabular berukuran ratusan hingga ribuan baris. Deep learning menonjol ketika data tidak terstruktur melimpah dan polanya kompleks. Pemilihan di antara ketiganya adalah keputusan teknis berbasis karakteristik data, bukan sekadar mengikuti tren.

Kini kita mengetahui posisi deep learning dalam peta AI dan telah melihat sendiri bagaimana transformasi berlapis mengubah piksel mentah menjadi fitur yang ringkas. Pertanyaan wajar berikutnya: kalau deep learning dan machine learning sama-sama belajar dari data, apa persisnya bedanya dan kapan masing-masing layak dipilih? Chapter berikutnya menjawabnya lewat eksperimen langsung pada dataset yang sama.