Neuron artifisial pada chapter sebelumnya baru berguna apabila bobot dan biasnya dipilih tepat. Perceptron, yang diperkenalkan Frank Rosenblatt pada 1958, adalah model pertama yang mampu menemukan bobot tersebut sendiri dari data lewat aturan pembelajaran sederhana. Pada chapter ini kita implementasikan aturan tersebut dengan NumPy murni: melatih perceptron pada data AND hingga konvergen, lalu membuktikan lewat percobaan nyata bahwa data XOR mustahil dipelajarinya — keterbatasan yang sempat menghentikan riset neural network lebih dari satu dekade. Pembuktian ini sekaligus menjadi pintu masuk menuju multilayer perceptron.

Sejarah Singkat Perceptron #

Rosenblatt membangun perceptron pertama sebagai perangkat keras bernama Mark I Perceptron di laboratorium Cornell Aeronautical: rangkaian potensiometer menggantikan bobot, dan mesin dilatih mengenali pola cahaya lewat array sensor. Publikasi dan pemberitaan pada masa itu menimbulkan ekspektasi besar terhadap mesin yang diklaim dapat belajar seperti manusia. Ekspektasi tersebut berbalik arah pada 1969 ketika Marvin Minsky dan Seymour Papert menerbitkan buku Perceptrons yang membuktikan secara matematis: perceptron satu layer tidak mungkin merepresentasikan fungsi XOR, sekecil apa pun bobot yang dipilih. Minat dan pendanaan riset neural network menurun tajam selama lebih dari satu dekade — periode yang kemudian dikenal sebagai AI winter — hingga metode pelatihan layer tersembunyi ditemukan pada era 1980-an.

Aturan Pembelajaran Perceptron #

Perceptron memakai neuron dengan fungsi step dari chapter Neuron Artifisial . Belajar berarti menggeser bobot dan bias setiap kali prediksi salah. Aturannya:

w_baru = w + η · (t − ŷ) · x dan b_baru = b + η · (t − ŷ)

dengan t target sebenarnya, ŷ prediksi step, dan η (eta) learning rate atau laju pembelajaran. Mekanismenya simetris dan mudah dibaca:

  • Target 1, prediksi 0: selisih t − ŷ = +1, bobot digeser mendekati vektor input sehingga skor z naik pada contoh tersebut.
  • Target 0, prediksi 1: selisih −1, bobot digeser menjauh dari input sehingga skor turun.
  • Prediksi benar: selisih 0, tidak ada pembaruan sama sekali.

Teorema konvergensi perceptron menjamin: selama data dapat dipisahkan oleh satu garis lurus (linearly separable), aturan ini berhenti dalam jumlah langkah hingga. Sebaliknya, jika data tidak linearly separable, aturan ini berputar tanpa henti — sifat inilah yang akan kita buktikan dengan percobaan. Model berusia lebih dari setengah abad ini tetap hidup di pustaka modern: scikit-learn menyediakan class Perceptron yang memakai aturan pembaharuan serupa untuk data linearly separable berskala besar.

Melatih Perceptron pada Gerbang AND #

Data AND terdiri atas empat titik dua dimensi; hanya titik (1, 1) yang berkelas 1. Berkas perceptron_latih.py menjalankan aturan di atas dengan parameter awal nol dan laju 1.0:

python 
"""Melatih perceptron pada data gerbang AND dengan aturan pembelajaran.

Aturan pembaruan hanya dijalankan saat prediksi salah:
    w_baru = w + laju * (target - prediksi) * x
    b_baru = b + laju * (target - prediksi)
"""

import numpy as np


def prediksi_baris(x, w, b):
    """Prediksi satu contoh: step atas z = w.x + b."""
    z = np.dot(w, x) + b
    return 1 if z >= 0.0 else 0


# Data gerbang AND: keluaran 1 hanya bila kedua masukan bernilai 1
X = np.array([
    [0.0, 0.0],
    [0.0, 1.0],
    [1.0, 0.0],
    [1.0, 1.0],
])
target = np.array([0, 0, 0, 1])

# Parameter awal: semua nol, perceptron belajar dari kesalahan
bobot = np.zeros(2)
bias = 0.0
laju = 1.0

print("Training perceptron pada data AND")
for epoch in range(1, 11):
    galat = 0
    for x, t in zip(X, target):
        pred = prediksi_baris(x, bobot, bias)
        if pred != t:
            galat += 1
            bobot = bobot + laju * (t - pred) * x
            bias = bias + laju * (t - pred)
    print(f"epoch {epoch:2d}: bobot={bobot} bias={bias:+.1f} galat={galat}")
    if galat == 0:
        print(f"Konvergen pada epoch {epoch} (tanpa kesalahan).")
        break

print()
print("Evaluasi akhir:")
for x, t in zip(X, target):
    z = np.dot(bobot, x) + bias
    pred = prediksi_baris(x, bobot, bias)
    status = "benar" if pred == t else "salah"
    print(f"  x={x.astype(int)} z={z:+.1f} prediksi={pred} target={t} -> {status}")

Output yang Dihasilkan:

text 
Training perceptron pada data AND
epoch  1: bobot=[1. 1.] bias=+0.0 galat=2
epoch  2: bobot=[2. 1.] bias=-1.0 galat=3
epoch  3: bobot=[2. 1.] bias=-2.0 galat=3
epoch  4: bobot=[2. 2.] bias=-2.0 galat=2
epoch  5: bobot=[2. 1.] bias=-3.0 galat=1
epoch  6: bobot=[2. 1.] bias=-3.0 galat=0
Konvergen pada epoch 6 (tanpa kesalahan).

Evaluasi akhir:
  x=[0 0] z=-3.0 prediksi=0 target=0 -> benar
  x=[0 1] z=-2.0 prediksi=0 target=0 -> benar
  x=[1 0] z=-1.0 prediksi=0 target=0 -> benar
  x=[1 1] z=+0.0 prediksi=1 target=1 -> benar

Enam epoch cukup: jumlah galat turun bergelombang 2 → 3 → 3 → 2 → 1 → 0, dan parameter akhir bobot = [2, 1], bias = -3 membentuk garis batas keputusan 2·x1 + x2 − 3 = 0 yang memisahkan titik (1, 1) dari tiga titik lainnya. Titik (1, 1) tepat menghasilkan z = 0 dan sesuai konvensi step kita, z >= 0 dihitung sebagai kelas 1. Mari kita telaah kodenya baris per baris:

  1. Baris 11-14 (def prediksi_baris): memindahkan neuron step dari chapter sebelumnya menjadi fungsi — hitung z, lalu keluarkan 1 atau 0.
  2. Baris 17-24 (X, target): data latih AND: empat contoh dua fitur beserta labelnya.
  3. Baris 26-29 (bobot, bias, laju): seluruh parameter dimulai dari nol; laju = 1.0 adalah pilihan klasik Rosenblatt.
  4. Baris 31-43 (loop epoch): tiap epoch mengulang seluruh contoh satu per satu, menghitung galat epoch, lalu memperbarui parameter hanya saat prediksi salah; loop berhenti begitu satu epoch penuh luput dari kesalahan.
  5. Baris 45-51 (evaluasi akhir): mencetak z, prediksi, dan target untuk keempat contoh sebagai bukti akhir.

Batasan Linear: XOR Gagal #

Data XOR menempatkan kelas 1 pada titik (0, 1) dan (1, 0) serta kelas 0 pada (0, 0) dan (1, 1) — dua pasang diagonal yang saling bersilangan. Tidak ada satu garis lurus pun yang mampu memisahkan kedua kelas tersebut, sehingga teorema konvergensi tidak berlaku. Berkas perceptron_xor.py memakai algoritma yang sama persis; hanya data dan batas epoch yang berbeda:

python 
"""Membuktikan keterbatasan perceptron: data XOR tidak pernah konvergen.

Algoritma dan laju pembelajaran sama persis dengan perceptron_latih.py,
hanya datanya diganti gerbang XOR. Jumlah galat terus berubah dan tidak
pernah mencapai nol sampai batas epoch tercapai.
"""

import numpy as np


def prediksi_baris(x, w, b):
    """Prediksi satu contoh: step atas z = w.x + b."""
    z = np.dot(w, x) + b
    return 1 if z >= 0.0 else 0


# Data gerbang XOR: keluaran 1 bila kedua masukan berbeda
X = np.array([
    [0.0, 0.0],
    [0.0, 1.0],
    [1.0, 0.0],
    [1.0, 1.0],
])
target = np.array([0, 1, 1, 0])

bobot = np.zeros(2)
bias = 0.0
laju = 1.0
batas_epoch = 15

print("Training perceptron pada data XOR")
konvergen = False
for epoch in range(1, batas_epoch + 1):
    galat = 0
    for x, t in zip(X, target):
        pred = prediksi_baris(x, bobot, bias)
        if pred != t:
            galat += 1
            bobot = bobot + laju * (t - pred) * x
            bias = bias + laju * (t - pred)
    print(f"epoch {epoch:2d}: bobot={bobot} bias={bias:+.1f} galat={galat}")
    if galat == 0:
        konvergen = True
        print(f"Konvergen pada epoch {epoch}.")
        break

if not konvergen:
    print(f"Batas {batas_epoch} epoch tercapai tanpa konvergen.")

print()
print("Evaluasi akhir:")
for x, t in zip(X, target):
    z = np.dot(bobot, x) + bias
    pred = prediksi_baris(x, bobot, bias)
    status = "benar" if pred == t else "salah"
    print(f"  x={x.astype(int)} z={z:+.1f} prediksi={pred} target={t} -> {status}")

Output yang Dihasilkan:

text 
Training perceptron pada data XOR
epoch  1: bobot=[-1.  0.] bias=-1.0 galat=3
epoch  2: bobot=[-1.  0.] bias=+0.0 galat=3
epoch  3: bobot=[-1.  0.] bias=+0.0 galat=4
epoch  4: bobot=[-1.  0.] bias=+0.0 galat=4
epoch  5: bobot=[-1.  0.] bias=+0.0 galat=4
epoch  6: bobot=[-1.  0.] bias=+0.0 galat=4
epoch  7: bobot=[-1.  0.] bias=+0.0 galat=4
epoch  8: bobot=[-1.  0.] bias=+0.0 galat=4
epoch  9: bobot=[-1.  0.] bias=+0.0 galat=4
epoch 10: bobot=[-1.  0.] bias=+0.0 galat=4
epoch 11: bobot=[-1.  0.] bias=+0.0 galat=4
epoch 12: bobot=[-1.  0.] bias=+0.0 galat=4
epoch 13: bobot=[-1.  0.] bias=+0.0 galat=4
epoch 14: bobot=[-1.  0.] bias=+0.0 galat=4
epoch 15: bobot=[-1.  0.] bias=+0.0 galat=4
Batas 15 epoch tercapai tanpa konvergen.

Evaluasi akhir:
  x=[0 0] z=+0.0 prediksi=1 target=0 -> salah
  x=[0 1] z=+0.0 prediksi=1 target=1 -> benar
  x=[1 0] z=-1.0 prediksi=0 target=1 -> salah
  x=[1 1] z=-1.0 prediksi=0 target=0 -> benar

Hasilnya tegas: sejak epoch ketiga, parameter terjebak pada bobot = [-1, 0], bias = 0, dengan seluruh empat contoh salah klasifikasi. Setiap pembaruan yang dilakukan pada satu contoh langsung dibatalkan oleh pembaruan contoh berikutnya, sehingga parameter berputar dalam siklus tanpa pernah menemukan garis pemisah — bukti nyata bahwa perceptron satu layer tidak bisa mempelajari XOR, sepuluh epoch pun atau sepuluh ribu. Dua hal yang berbeda dari skrip sebelumnya:

  1. Baris 29 (batas_epoch = 15): memberi langkah berhenti karena konvergen tidak akan pernah terjadi; tanpa batas ini loop berjalan selamanya.
  2. Baris 32, 42-48 (konvergen): penanda bersyarat yang membedakan “berhenti karena sukses” dari “berhenti karena kehabisan epoch”.

Jalan Keluar: Menumpuk Layer #

Keterbatasan tersebut teratasi bukan dengan mengubah aturan pembelajaran, melainkan dengan menambahkan layer tersembunyi antara input dan output. Layer tersembunyi memetakan data ke ruang fitur baru yang lebih ramah terhadap garis pemisah — gagasan yang persis sama dengan pembelajaran fitur otomatis yang kita kenal pada chapter Deep Learning vs Machine Learning . Chapter berikutnya membuktikannya: sebuah jaringan 2-2-1 dengan bobot yang ditulis manual akan menyelesaikan XOR yang barusan menjatuhkan perceptron kita.