KamusNgoding
Pemula Deep-learning 5 menit baca

Apa itu Neural Network? Penjelasan Lengkap untuk Pemula

#neural network #deep learning #ai #beginner

Apa itu Neural Network? Penjelasan Lengkap untuk Pemula

Pendahuluan

Pernahkah kamu bertanya-tanya bagaimana aplikasi bisa mengenali wajahmu untuk membuka kunci layar? Atau bagaimana asisten virtual seperti Siri bisa memahami ucapanmu? Di balik semua kecanggihan itu, ada teknologi bernama Neural Network (Jaringan Saraf Tiruan).

Neural Network adalah fondasi dari banyak sistem kecerdasan buatan modern. Jika kamu sudah membaca artikel tentang Apa itu Deep Learning?, kamu mungkin sudah mendengar istilah ini. Artikel ini akan menggali lebih dalam: bukan tentang apa yang bisa dilakukan Neural Network, tapi bagaimana cara kerjanya dari nol.

Tenang saja — kita akan mulai dari analogi sederhana, bukan rumus matematika yang rumit.

Memahami Neural Network Melalui Analogi Otak Manusia

Bayangkan otakmu sedang belajar mengenali buah mangga. Pertama kali kamu melihat mangga, orang tuamu bilang: “Ini mangga.” Otak kamu menyimpan informasi: bentuknya lonjong, warnanya kuning-hijau, baunya manis. Lain kali kamu melihat benda serupa, otak langsung bereaksi — “Itu mangga!”

Neural Network bekerja persis seperti itu.

Otak manusia terdiri dari miliaran neuron (sel saraf) yang saling terhubung. Ketika kamu belajar sesuatu, koneksi antar neuron menguat. Neural Network tiruan meniru prinsip ini menggunakan komputer:

  • Neuron biologis → digantikan oleh node (simpul) dalam program
  • Koneksi antar neuron → digantikan oleh bobot (weights) berupa angka
  • Sinyal listrik → digantikan oleh angka yang mengalir antar node
  • Belajar dari pengalaman → digantikan oleh proses training dengan data

Jika kamu ingin membangun aplikasi rekomendasi produk seperti Tokopedia atau Shopee, Neural Network bisa mempelajari pola pembelian jutaan pengguna dan memberikan saran yang relevan — tanpa kamu harus memprogram aturannya satu per satu.

Komponen Utama dalam Neural Network

Setiap Neural Network terdiri dari tiga bagian utama:

1. Input Layer (Lapisan Masukan)

Ini adalah pintu masuk data. Misalnya, jika kamu memasukkan gambar 28×28 piksel, input layer akan memiliki 784 node (satu per piksel).

2. Hidden Layer (Lapisan Tersembunyi)

Inilah tempat “keajaiban” terjadi. Data diolah, pola dikenali, dan fitur diekstrak. Satu Neural Network bisa punya satu atau banyak hidden layer — semakin banyak lapisan, semakin dalam ia bisa belajar pola yang kompleks.

3. Output Layer (Lapisan Keluaran)

Hasil akhir prediksi. Misalnya untuk klasifikasi gambar angka 0–9, output layer memiliki 10 node — masing-masing mewakili satu angka.

import numpy as np

# Simulasi neural network sederhana:
# 2 input -> 3 neuron hidden layer -> 1 output

# Seed dipakai agar hasil acak selalu sama saat kode dijalankan ulang
np.random.seed(42)

# Inisialisasi bobot secara acak
bobot_input_hidden = np.random.randn(2, 3)   # dari 2 fitur input ke 3 neuron hidden
bobot_hidden_output = np.random.randn(3, 1)  # dari 3 neuron hidden ke 1 neuron output

# Fungsi aktivasi sigmoid untuk mengubah nilai menjadi rentang 0 sampai 1
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# Data contoh:
# [jam_belajar, jam_tidur] -> [lulus?]
X = np.array([
    [8, 7],
    [3, 4],
    [6, 8],
    [2, 3]
])

y = np.array([
    [1],
    [0],
    [1],
    [0]
])

# Forward pass: data bergerak dari input ke hidden layer
input_hidden = np.dot(X, bobot_input_hidden)
output_hidden = sigmoid(input_hidden)

# Lalu dari hidden layer ke output layer
input_output = np.dot(output_hidden, bobot_hidden_output)
prediksi = sigmoid(input_output)

# Tampilkan hasil prediksi
print("Prediksi probabilitas lulus:")
print(prediksi.flatten().round(2))

# Output yang diharapkan:
# > Prediksi probabilitas lulus:
# > [0.76 0.8  0.77 0.81]

Bagaimana Neural Network Belajar?

Proses belajar Neural Network melibatkan dua langkah utama yang diulang berkali-kali:

Forward Propagation (Maju)

Data mengalir dari input layer → hidden layer → output layer, menghasilkan prediksi.

Backpropagation (Mundur)

Neural Network membandingkan prediksinya dengan jawaban yang benar, menghitung selisihnya (loss/error), lalu menyesuaikan bobot ke belakang agar prediksi berikutnya lebih akurat.

Proses ini mirip seperti seorang chef yang mencicipi masakannya, menyadari kurang garam, lalu menambahkan garam dan mencicipi lagi — berulang hingga rasanya pas.

import numpy as np

# Fungsi aktivasi sigmoid
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# Turunan sigmoid untuk backpropagation
def sigmoid_turunan(x):
    return x * (1 - x)

# Data latihan untuk masalah XOR
X = np.array([
    [0, 0],
    [0, 1],
    [1, 0],
    [1, 1]
])

y = np.array([
    [0],
    [1],
    [1],
    [0]
])

# Inisialisasi bobot dan bias agar hasil selalu sama saat dijalankan
np.random.seed(1)
w1 = np.random.randn(2, 4)
b1 = np.zeros((1, 4))
w2 = np.random.randn(4, 1)
b2 = np.zeros((1, 1))

learning_rate = 0.5
epochs = 10000

# Proses training
for epoch in range(epochs):
    # Forward pass: input -> hidden layer -> output layer
    hidden = sigmoid(np.dot(X, w1) + b1)
    output = sigmoid(np.dot(hidden, w2) + b2)

    # Hitung error
    error = y - output

    # Backpropagation
    d_output = error * sigmoid_turunan(output)
    d_hidden = np.dot(d_output, w2.T) * sigmoid_turunan(hidden)

    # Update bobot dan bias
    w2 += np.dot(hidden.T, d_output) * learning_rate
    b2 += np.sum(d_output, axis=0, keepdims=True) * learning_rate
    w1 += np.dot(X.T, d_hidden) * learning_rate
    b1 += np.sum(d_hidden, axis=0, keepdims=True) * learning_rate

# Ubah hasil menjadi 0 atau 1
prediksi = (output > 0.5).astype(int)

print("Prediksi akhir:")
print(prediksi)

# Output yang diharapkan:
# > Prediksi akhir:
# > [[0]
# >  [1]
# >  [1]
# >  [0]]

Learning Rate adalah seberapa besar langkah penyesuaian bobot. Terlalu besar → melompati solusi terbaik. Terlalu kecil → belajarnya lama sekali. Konsep ini mirip dengan memahami iterasi dalam struktur data — kamu perlu tahu kapan harus berhenti.

Contoh Kasus Nyata

Mari kita gunakan library scikit-learn untuk membangun Neural Network yang mengklasifikasikan jenis bunga Iris — salah satu dataset klasik dalam machine learning.

from sklearn.datasets import load_iris
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.preprocessing import StandardScaler

# 1. Muat dataset Iris
iris = load_iris()
X = iris.data
y = iris.target

# 2. Bagi data menjadi data latih dan data uji
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# 3. Normalisasi fitur agar pelatihan neural network lebih stabil
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# 4. Buat model neural network sederhana
model = MLPClassifier(
    hidden_layer_sizes=(16,),  # 1 hidden layer dengan 16 neuron
    activation="relu",
    max_iter=500,
    random_state=42
)

# 5. Latih model dengan data latih
model.fit(X_train, y_train)

# 6. Uji model dengan data uji
y_pred = model.predict(X_test)
akurasi = accuracy_score(y_test, y_pred)

# 7. Tampilkan akurasi model
print(f"Akurasi model: {akurasi * 100:.1f}%")

# 8. Coba prediksi satu data baru
sampel_baru = [[5.1, 3.5, 1.4, 0.2]]
sampel_baru_scaled = scaler.transform(sampel_baru)
hasil_prediksi = model.predict(sampel_baru_scaled)

# 9. Ubah hasil angka menjadi nama bunga
nama_bunga = iris.target_names[hasil_prediksi[0]]
print(f"Prediksi jenis bunga: {nama_bunga}")

# Output yang diharapkan:
# > Akurasi model: 96.7%
# > Prediksi jenis bunga: setosa

Kamu bisa menerapkan pola yang sama untuk kasus nyata — misalnya jika ingin membangun sistem deteksi penipuan transaksi seperti yang dibutuhkan layanan keuangan digital. Data transaksinya bisa dibaca dari file CSV menggunakan panduan di tutorial pengolahan file CSV dengan Python.

Troubleshooting: Error yang Sering Muncul

ValueError: Input contains NaN or infinity

Penyebab: Data masukan mengandung nilai kosong (NaN) atau tidak terbatas (inf), yang tidak bisa diproses oleh Neural Network.

Solusi:

import pandas as pd
import numpy as np

# Membuat contoh DataFrame dengan beberapa nilai NaN
df = pd.DataFrame({
    "umur": [20, 21, np.nan, 23],
    "nilai": [80, np.nan, 90, 85]
})

# Menampilkan jumlah nilai NaN di setiap kolom
print("Jumlah NaN sebelum dibersihkan:")
print(df.isnull().sum())

# Opsi 1: Hapus baris yang memiliki NaN
# df_bersih = df.dropna()

# Opsi 2: Isi NaN dengan rata-rata kolom numerik
df_bersih = df.fillna(df.mean(numeric_only=True))

# Menampilkan jumlah total NaN setelah dibersihkan
print("\nJumlah NaN setelah dibersihkan:", df_bersih.isnull().sum().sum())

# Menampilkan data setelah dibersihkan
print("\nData setelah dibersihkan:")
print(df_bersih)

# Output yang diharapkan:
# > Jumlah NaN sebelum dibersihkan:
# > umur     1
# > nilai    1
# > dtype: int64
# >
# > Jumlah NaN setelah dibersihkan: 0
# >
# > Data setelah dibersihkan:
# >         umur  nilai
# > 0  20.000000   80.0
# > 1  21.000000   85.0
# > 2  21.333333   90.0
# > 3  23.000000   85.0

Model Tidak Konvergen / Loss Tidak Turun

Penyebab: Learning rate terlalu besar atau terlalu kecil, atau data belum dinormalisasi sehingga gradient menjadi tidak stabil.

Solusi:

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.preprocessing import StandardScaler

# Siapkan dataset sederhana untuk contoh
data = load_iris()
X = data.data
y = data.target

# Bagi data menjadi data latih dan data uji
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# WAJIB: normalisasi data sebelum training agar model lebih stabil
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)  # fit + transform data latih
X_test_scaled = scaler.transform(X_test)        # transform data uji

# Buat model neural network dengan konfigurasi yang stabil
model = MLPClassifier(
    hidden_layer_sizes=(100, 50),  # 2 hidden layer
    learning_rate_init=0.001,      # learning rate awal yang kecil dan aman
    max_iter=1000,                 # jumlah iterasi maksimum
    early_stopping=True,           # berhenti jika performa tidak membaik
    random_state=42
)

# Latih model dengan data yang sudah dinormalisasi
model.fit(X_train_scaled, y_train)

# Hitung akurasi pada data uji
accuracy = model.score(X_test_scaled, y_test)
print(f"Akurasi data uji: {accuracy:.2f}")

# Output yang diharapkan:
# > Akurasi data uji: 0.97

MemoryError saat Training Data Besar

Penyebab: Dataset terlalu besar untuk dimuat sekaligus ke memori RAM, terutama saat menggunakan array NumPy atau Pandas yang besar.

Solusi:

import pandas as pd
from sklearn.neural_network import MLPClassifier

# Contoh 1: model MLP dengan mini-batch
# Data kecil untuk contoh yang langsung bisa dijalankan
data = pd.DataFrame({
    "fitur_1": [0, 0, 1, 1],
    "fitur_2": [0, 1, 0, 1],
    "label":   [0, 1, 1, 0]
})

# Pisahkan fitur (X) dan label (y)
X = data.drop("label", axis=1).values
y = data["label"].values

# Buat model neural network sederhana
model = MLPClassifier(
    hidden_layer_sizes=(64,),  # 1 hidden layer dengan 64 neuron
    solver="adam",             # optimizer yang cocok untuk pemula
    batch_size=2,              # proses data sedikit demi sedikit
    max_iter=200,
    random_state=42
)

# Latih model
model.fit(X, y)

# Lakukan prediksi
prediksi = model.predict(X)
print("Prediksi model batch:", prediksi.tolist())

# Contoh 2: training bertahap dengan partial_fit
# Simpan data ke CSV agar contoh chunksize bisa dijalankan
data.to_csv("data_besar.csv", index=False)

# Buat model untuk incremental learning
model_incremental = MLPClassifier(
    hidden_layer_sizes=(64,),
    max_iter=1,                # 1 iterasi per potongan data
    random_state=42
)

# Baca file CSV sedikit demi sedikit
for chunk in pd.read_csv("data_besar.csv", chunksize=2):
    X_chunk = chunk.drop("label", axis=1).values
    y_chunk = chunk["label"].values

    # partial_fit melatih model secara bertahap
    model_incremental.partial_fit(X_chunk, y_chunk, classes=[0, 1])

# Prediksi setelah training bertahap selesai
prediksi_incremental = model_incremental.predict(X)
print("Prediksi model incremental:", prediksi_incremental.tolist())

# Output yang diharapkan:
# > Prediksi model batch: [0, 1, 1, 0]
# > Prediksi model incremental: [0, 1, 1, 0]

Pertanyaan yang Sering Diajukan

Apa perbedaan Neural Network dan Deep Learning?

Deep Learning adalah subset dari Neural Network. Semua Deep Learning menggunakan Neural Network, tapi tidak semua Neural Network disebut Deep Learning. “Deep” mengacu pada banyaknya hidden layer — jika ada dua layer atau lebih, barulah disebut Deep Learning.

Berapa banyak data yang dibutuhkan untuk melatih Neural Network?

Tidak ada angka pasti, tapi aturan umumnya: semakin kompleks masalahnya, semakin banyak data yang dibutuhkan. Untuk masalah sederhana seperti klasifikasi teks pendek, ratusan sampel bisa cukup. Untuk pengenalan gambar yang kompleks, kamu mungkin butuh ribuan hingga jutaan sampel.

Apakah harus paham matematika dalam untuk belajar Neural Network?

Tidak harus di awal. Kamu bisa mulai dengan library seperti scikit-learn atau Keras yang menyembunyikan kompleksitas matematikanya. Namun untuk memahami kenapa model berperilaku tertentu atau melakukan optimasi lanjutan, pemahaman tentang aljabar linear dan kalkulus dasar akan sangat membantu.

Apa itu fungsi aktivasi dan mengapa penting?

Fungsi aktivasi menentukan apakah sebuah neuron “menyala” atau tidak berdasarkan inputnya. Tanpa fungsi aktivasi, Neural Network hanya akan melakukan operasi linear sederhana — tidak bisa mempelajari pola yang kompleks dan non-linear. Fungsi umum: Sigmoid (untuk output 0–1), ReLU (paling populer untuk hidden layer), Softmax (untuk klasifikasi multi-kelas).

Bagaimana cara memilih jumlah hidden layer dan node yang tepat?

Ini lebih seni daripada sains. Aturan praktis: mulai dengan 1–2 hidden layer dan jumlah node antara ukuran input dan output. Gunakan validasi silang (cross-validation) untuk membandingkan konfigurasi berbeda. Jangan langsung buat model yang sangat besar — mulai kecil, lalu tambah kompleksitas jika akurasi belum cukup.

Kesimpulan

Neural Network adalah sistem komputasi yang terinspirasi dari cara kerja otak manusia — terdiri dari layer input, hidden, dan output yang saling terhubung melalui bobot. Proses belajarnya melibatkan forward propagation untuk menghasilkan prediksi dan backpropagation untuk memperbaiki kesalahan secara iteratif.

Kamu sudah belajar cara kerja Neural Network dari analogi sederhana hingga implementasi nyata dengan Python. Langkah selanjutnya? Coba eksperimen dengan dataset yang berbeda, ubah jumlah hidden layer, atau pelajari library seperti TensorFlow dan PyTorch untuk membangun model yang lebih canggih.

Selamat belajar dan terus berlatih! Fondasi yang kuat dimulai dari pemahaman konsep dasar seperti ini — jangan ragu untuk eksplorasi artikel-artikel lainnya di KamusNgoding dan jadilah developer Indonesia yang siap menghadapi era AI.

Artikel Terkait

deep-learning Apa itu Deep Learning? Penjelasan Lengkap untuk Pemula deep-learning CNN vs RNN: Perbedaan dan Kapan Menggunakannya deep-learning Memahami Backpropagation di Neural Network